godprotocol 1.1.3 → 1.1.32

package/Objects/Account.js

@@ -2,67 +2,119 @@ import Utils from "./Utils";
 import register from "../callables/register";
 import Chain from "./Chain";
 import Virtual_machine from "./Virtual_machine";
-import Compiler from "../../../compiler/compiler";
 
 class Account extends Utils {
   constructor(name, options) {
-    super()
+    super();
 
     this.name = name;
 
     this.manager = options.manager;
-    this.parent = options.parent || this
+    this.parent = options.parent || this;
     this.repository = this.manager.repository;
-    this.account = this
+    this.account = this;
 
     this.physical_address = `Accounts/${name}`;
-    this.buffs = new Array()
+    this.buffs = new Array();
 
     this.chain = new Chain(this.physical_address, this.parent);
-    this.path = this.chain.path
+    this.path = this.chain.path;
+
+    console.log(`Account Created: ${this.name}`);
   }
 
   load = async (payload) => {
-    let { sequence: codes, physical_address } = payload;
-
-    physical_address = `${this.physical_address}/${physical_address}`
-    
-    let chain = await this.chain.chain(physical_address, {root:true})
-
-    return {value: await chain.add_config(codes), type:'address'}
+    let { sequence: codes, account, physical_address, options } = payload;
+
+    console.log(payload);
+    if (account && account !== this.name) {
+      account = await this.manager.get_account(account);
+      if (account) {
+        return await account.load(payload);
+      } else return { error: true, message: "Account not found!" };
+    }
+
+    if (typeof codes === "string") {
+      codes = await this.compiler.to_sequence(codes, physical_address);
+      if (options) {
+        codes = codes[0].body[options.line];
+      }
+    }
+    if (Array.isArray(codes)) {
+      codes = codes[0];
+    }
+
+    physical_address = `${this.physical_address}/${physical_address}`;
+
+    let chain = await this.chain.chain(physical_address);
+
+    let res = { value: await chain.add_config(codes), type: "address" };
+
+    console.log(res, codes, chain.physical_address);
+    return res;
   };
 
   run = async (payload) => {
-    let { physical_address, account } = payload;
-
-    let acc = await this.manager.get_account(account) || this;
-    let chain = await acc.chain.chain(`${acc.physical_address}/${physical_address}`)
-
-    let config = await chain.read({config: true})
-    return await this.vm.execute(config, {chain, main:true})
+    let { physical_address, account, options } = payload;
+
+    let acc = (await this.manager.get_account(account)) || this;
+    let chain = await acc.chain.chain(
+      `${acc.physical_address}/${physical_address}`
+    );
+
+    console.log(chain.physical_address);
+    let config = await chain.read({ config: true });
+
+    if (options.env) {
+      let res = await this.load({
+        sequence: `env = ${JSON.stringify(options.env)}`,
+        physical_address: `${physical_address}`,
+        options: { line: 0 },
+      });
+      await this.vm.execute(res.value, { chain });
+    }
+
+    let res = await this.vm.execute(config, { chain, main: true });
+    if (options && options.literal) {
+      if (res.type === "address") {
+        let conf = await this.vm.resolve_address(res.value);
+        res = {
+          address: res,
+          literal: await (await this.vm.cloth_content(conf)).literal(),
+        };
+      }
+    }
+
+    return res;
   };
 
-  parse = async(payload)=>{
-    let {account, physical_address, depth, history, query} = payload;
+  parse = async (payload) => {
+    let { account, physical_address, depth, history, query } = payload;
 
-    let acc = await this.manager.get_account(account) || this;
-    let chain = await acc.chain.chain(`${acc.physical_address}/${physical_address}`)
+    let acc = (await this.manager.get_account(account)) || this;
+    let chain = await acc.chain.chain(
+      `${acc.physical_address}/${physical_address}`
+    );
 
-    let config = await chain.read({query, depth, history});
+    let config = await chain.read({ query, depth, history });
     return config;
-  }
+  };
 
-  add_account = async(name, options)=>{
-    let acc = new Account(name, {...options, manager: this.manager, parent: this})
-    await acc.sync()
+  add_account = async (name, options) => {
+    let acc = new Account(name, {
+      ...options,
+      manager: this.manager,
+      parent: this,
+    });
+    await acc.sync();
 
-    return acc
-  }
+    return acc;
+  };
 
   sync = async () => {
     this.servers = new Array();
     this.vm = new Virtual_machine(this);
-    this.aircode = new Compiler(this)
+    this.compiler = new this.manager.compiler(this);
 
     await this.chain.sync();
     await this.vm.sync();
@@ -70,9 +122,14 @@ class Account extends Utils {
     await register(this);
   };
 
-  stringify = ()=>{
-    return {physical_address: this.physical_address, path: this.path, name: this.name, private: this.private}
-  }
+  stringify = () => {
+    return {
+      physical_address: this.physical_address,
+      path: this.path,
+      name: this.name,
+      private: this.private,
+    };
+  };
 }
 
 export default Account;

package/Objects/Callable.js

@@ -7,184 +7,230 @@ class Callable extends Vm_utils {
     this.objects = new Object();
   }
 
-  parse_aircode = async(result, {config, chain})=>{
-    if (result == null)result = 'void';
+  parse_aircode = async (result, { config, chain }) => {
+    if (result == null) result = "void";
 
-    let res = await this.account.aircode.to_sequence(JSON.stringify(result), config.location.split('/').slice(2).join('/'))[0].body[0]
+    let res = await this.account.compiler.to_sequence(
+      JSON.stringify(result),
+      config.location.split("/").slice(2).join("/")
+    )[0].body[0];
 
-    await chain.add_config(res)
-    result = await this.execute(res, {chain})
+    await chain.add_config(res);
+    result = await this.execute(res, { chain });
 
-    return result
-  }
+    return result;
+  };
 
-  resolve_address = async (path, chain)=>{
-    let oracle = this.account.manager.oracle, 
+  resolve_address = async (path, chain) => {
+    let oracle = this.account.manager.oracle,
       fs = oracle.fs;
 
-    if (typeof path !== 'string'){
-      return path
+    if (typeof path !== "string") {
+      return path;
     }
 
-    if(path == 'g')throw new Error()
-    let conf = await fs.read(`${path}/.config`), value;
-    if (!conf.current){
-      value = await fs.read(`${path}/${conf.index-1}`)
-      value = JSON.parse(value.content)
-    }else value = await fs.read(`${path}/${conf.current}`)
-    value.path = path
-    
+    if (path == "g") throw new Error();
+    let conf = await fs.read(`${path}/.config`),
+      value;
+    if (!conf.current) {
+      value = await fs.read(`${path}/${conf.index - 1}`);
+      value = JSON.parse(value.content);
+    } else value = await fs.read(`${path}/${conf.current}`);
+    value.path = path;
+
     return value;
-  }
+  };
 
-  instantiate = async(config, {chain, hash, pure})=>{
-    let instance_chain = await chain.chain(config.type === 'void'? config.value : config.location);
-    let uid = this.gen_uid()
-
-    if (config.type === 'twain'){
-      if (!pure){
-        for (let p in config.value){
-          let pair = config.value[p]
-  
-          pair[0] = (await this.execute(pair[0], {chain})).value
-          pair[1] = (await this.execute(pair[1], {chain})).value
+  instantiate = async (config, { chain, hash, pure }) => {
+    let instance_chain = await chain.chain(
+      config.type === "void" ? config.value : config.location
+    );
+    let uid = this.gen_uid();
+
+    if (config.type === "twain") {
+      if (!pure) {
+        for (let p in config.value) {
+          let pair = config.value[p];
+
+          pair[0] = (await this.execute(pair[0], { chain })).value;
+          pair[1] = (await this.execute(pair[1], { chain })).value;
         }
       }
-     
-      config.value = JSON.stringify(config.value)
-    }else if(config.type === 'array'){
-      if (!pure){
-        for (let i=0; i< config.value.length; i++){
-          let item = config.value[i]
-          config.value[i] = (await this.execute(item, {chain})).value
+
+      config.value = JSON.stringify(config.value);
+    } else if (config.type === "array") {
+      if (!pure) {
+        for (let i = 0; i < config.value.length; i++) {
+          let item = config.value[i];
+          config.value[i] = (await this.execute(item, { chain })).value;
         }
       }
-      config.value = JSON.stringify(config.value)
+      config.value = JSON.stringify(config.value);
     }
 
-    let res = await instance_chain.write({content: config.value, __classifier__: config.type, uid}, {hash, is_instance: true})
+    let res = await instance_chain.write(
+      { content: config.value, __classifier__: config.type, uid },
+      { hash, is_instance: true }
+    );
     return res;
-  }
+  };
 
-  operate_result = async (value, call_config, chain)=>{
+  operate_result = async (value, call_config, chain) => {
     let result;
-    if (value && value.error){
-      result = value
-    }else if(value && value.type === 'address'){
-      result = value
-    } else result = await this.parse_aircode(value, {config: call_config, chain})
+    if (value && value.error) {
+      result = value;
+    } else if (value && value.type === "address") {
+      result = value;
+    } else
+      result = await this.parse_aircode(value, { config: call_config, chain });
 
-    return result
-  }
+    return result;
+  };
 
-  object_identifier = async (call_config, chain)=>{
-    let {identifier, }= call_config, result, oracle = this.account.manager.oracle;
-    let conf = await oracle.fs.read(`${identifier.object}/.config`)
+  object_identifier = async (call_config, chain) => {
+    let { identifier } = call_config,
+      result,
+      oracle = this.account.manager.oracle;
+    let conf = await oracle.fs.read(`${identifier.object}/.config`);
     let obj = await oracle.fs.read(`${identifier.object}/${conf.current}`);
 
-    let res = await this.cloth_content({...obj, path: identifier.object})
-    let classifier = await res.get('__classifier__')
-    
-    if (this.datatypes.includes(classifier)){
-      for (let a=0; a < call_config.arguments.length; a++)
-        call_config.arguments[a] = await this.execute(call_config.arguments[a], {chain, cloth: true})
-      
-      let value = await res.operate(identifier.value, call_config.arguments, {classifier, config: call_config, chain})
-      result = await this.operate_result(value, call_config, chain)
-    }else {
-      let conf = await oracle.fs.read(`${identifier.value}/.config`)
-      conf = await oracle.fs.read(`${identifier.value}/${conf.index-1}`)
-      let content = JSON.parse(conf.content)
-
-      let val = await this.execute(content, {chain, call_config: {...call_config, object: {type:'address', value: identifier.object}}})
-
-      result = val
+    let res = await this.cloth_content({ ...obj, path: identifier.object });
+    let classifier = await res.get("__classifier__");
+
+    if (this.datatypes.includes(classifier)) {
+      for (let a = 0; a < call_config.arguments.length; a++)
+        call_config.arguments[a] = await this.execute(
+          call_config.arguments[a],
+          { chain, cloth: true }
+        );
+
+      let value = await res.operate(identifier.value, call_config.arguments, {
+        classifier,
+        config: call_config,
+        chain,
+      });
+      result = await this.operate_result(value, call_config, chain);
+    } else {
+      let conf = await oracle.fs.read(`${identifier.value}/.config`);
+      conf = await oracle.fs.read(`${identifier.value}/${conf.index - 1}`);
+      let content = JSON.parse(conf.content);
+
+      let val = await this.execute(content, {
+        chain,
+        call_config: {
+          ...call_config,
+          object: { type: "address", value: identifier.object },
+        },
+      });
+
+      result = val;
     }
 
-    return result
-  }
+    return result;
+  };
 
-  execute_call = async(call_config, {chain, obj})=>{
-    let {identifier, arguments: args} = call_config, result;
-
-    if(typeof identifier !== 'string'){
-      if (identifier.object){
-        result = await this.object_identifier(call_config, chain)
-      }else {
-        let conf = await this.read_config(identifier.value)
-        if(!['function', 'class'].includes(conf.type)){
-          conf = await obj.get(identifier.prev_name, {obj:identifier.prev_name})
-          conf = await this.resolve_address(conf.value)
+  execute_call = async (call_config, { chain, obj }) => {
+    let { identifier, arguments: args } = call_config,
+      result;
+
+    if (typeof identifier !== "string") {
+      if (identifier.object) {
+        result = await this.object_identifier(call_config, chain);
+      } else {
+        let conf = await this.read_config(identifier.value);
+        if (!["function", "class"].includes(conf.type)) {
+          conf = await obj.get(identifier.prev_name, {
+            obj: identifier.prev_name,
+          });
+          conf = await this.resolve_address(conf.value);
         }
-        result = await this.execute(conf, {call_config, chain})
+        result = await this.execute(conf, { call_config, chain });
       }
-    } else if (identifier.includes('/')){
+    } else if (identifier.includes("/")) {
       let oracle = this.account.manager.oracle;
-      let i_chain = identifier.startsWith(this.account.manager.path)? {path: identifier} : await chain.chain(identifier)
-      let conf = await oracle.fs.read(`${i_chain.path}/.config`)
-      
-      if(conf.sibling){
-        let config = await oracle.fs.read(conf.sibling)
-        
-        if (config.content.type === 'address'){
-          if (config.content.object){
-            result = await this.object_identifier({...call_config, identifier: config.content}, chain)
-          }else {
+      let i_chain = identifier.startsWith(this.account.manager.path)
+        ? { path: identifier }
+        : await chain.chain(identifier);
+      let conf = await oracle.fs.read(`${i_chain.path}/.config`);
+
+      if (conf.sibling) {
+        let config = await oracle.fs.read(conf.sibling);
+
+        if (config.content.type === "address") {
+          if (config.content.object) {
+            result = await this.object_identifier(
+              { ...call_config, identifier: config.content },
+              chain
+            );
+          } else {
             let iconf = await oracle.fs.read(`${config.content.value}/.config`);
-            let configg = await oracle.fs.read(`${config.content.value}/${iconf.index-1}`)
-            
-            result = await this.execute(JSON.parse(configg.content), {call_config, chain})
-          } 
+            let configg = await oracle.fs.read(
+              `${config.content.value}/${iconf.index - 1}`
+            );
+
+            result = await this.execute(JSON.parse(configg.content), {
+              call_config,
+              chain,
+            });
+          }
         }
-      }else if(conf.current) {
+      } else if (conf.current) {
         let iconf = await oracle.fs.read(`${conf.current}/.config`);
-        let config = await oracle.fs.read(`${conf.current}/${iconf.index-1}`)
-        
-        result = await this.execute(JSON.parse(config.content), {call_config, chain})
-      }else {
-        let config = await oracle.fs.read(`${call_config.identifier}/${conf.index-1}`)
-        result = await this.execute(JSON.parse(config.content), {call_config, chain})
+        let config = await oracle.fs.read(`${conf.current}/${iconf.index - 1}`);
+
+        result = await this.execute(JSON.parse(config.content), {
+          call_config,
+          chain,
+        });
+      } else {
+        let config = await oracle.fs.read(
+          `${call_config.identifier}/${conf.index - 1}`
+        );
+        result = await this.execute(JSON.parse(config.content), {
+          call_config,
+          chain,
+        });
       }
-     }
-    else {
-      if (this.datatypes.includes(identifier)){}
-      else {
-        let {callable, config} = await this.callable(identifier)
-        let data = {}
-        
-        for (let a=0; a< args.length; a++){
-          let param;
-          let arg = args[a]
-          if(arg.identifier){
+    } else {
+      if (this.datatypes.includes(identifier)) {
+      } else {
+        let { callable, config } = await this.callable(identifier);
+        let data = {};
 
-          }else {
-            param = config.parameters[arg.position]
-            if (!param){
-              let lst_param = config.parameters.slice(-1)[0]
+        for (let a = 0; a < args.length; a++) {
+          let param;
+          let arg = args[a];
+          if (arg.identifier) {
+          } else {
+            param = config.parameters[arg.position];
+            if (!param) {
+              let lst_param = config.parameters.slice(-1)[0];
               if (lst_param.spread) param = lst_param;
             }
           }
-          let res = await this.execute(arg, {chain, cloth: true})
-          if (param.spread){
-            let arr = data[param.name]
-            if (!arr){
+          let res = await this.execute(arg, { chain, cloth: true });
+          if (param.spread) {
+            let arr = data[param.name];
+            if (!arr) {
               arr = new Array();
               data[param.name] = arr;
             }
-            arr.push(res)
-          }else data[param.name] = res;
+            arr.push(res);
+          } else data[param.name] = res;
         }
-        
-        result = await callable(data)
-        if (identifier === 'exit' || identifier === 'Twain'){
-          
-        }else result = await this.parse_aircode(result, {config: call_config, chain})
+
+        result = await callable(data, { vm: this, config, chain });
+        if (["Twain", "exit", "render"].includes(identifier)) {
+        } else
+          result = await this.parse_aircode(result, {
+            config: call_config,
+            chain,
+          });
       }
     }
 
-    return result 
-  }
-  
+    return result;
+  };
 
   callable = async (name) => {
     let object = this.objects[name];
@@ -195,6 +241,25 @@ class Callable extends Vm_utils {
   set = (name, config) => {
     this.objects[name] = config;
   };
+
+  native_components = async (config, chain) => {
+    let props = await this.execute(config.props, { chain, cloth: true });
+    let children = new Array();
+    for (let c = 0; c < config.children.length; c++) {
+      let child = config.children[c];
+
+      let res = await this.execute(child, { chain, cloth: true });
+      children.push(await res.literal());
+    }
+
+    let obj = {
+      name: config.name,
+      props: await props.literal(),
+      children,
+    };
+
+    return obj;
+  };
 }
 
 export default Callable;

package/Objects/Chain.js

@@ -6,7 +6,7 @@ class Folder extends Storage{
 
     this.account = parent.account;
     this.physical_address = address
-    this.path = `${this.account.manager.path}/${this.physical_address}`
+    this.path = ${this.account.manager.path}/${this.physical_address}
     this.parent = parent;
   }
 
@@ -20,8 +20,8 @@ class Folder extends Storage{
   }
 
   chain = async(address)=>{
-    if (!address.includes('/'))address = `${this.physical_address}/${address}`
-    
+    if (!address.includes('/'))address = ${this.physical_address}/${address}
+
     let chain = await this.account.manager.web.set(address, this)
     return chain;
   }
@@ -30,20 +30,20 @@ class Folder extends Storage{
     let res;
     if (content && content.type === 'address' && options.hash) {
       let oracle = this.account.manager.oracle;
-      let conf = await oracle.fs.read(`${this.path}/.config`) || {}
-      
-      let pth = `${this.path}/${options.hash}`
-      let p_conf = await oracle.fs.read(`${pth}/.config`) || {}
+      let conf = await oracle.fs.read(${this.path}/.config) || {}
+
+      let pth = ${this.path}/${options.hash}
+      let p_conf = await oracle.fs.read(${pth}/.config) || {}
       let obj = {content, type: 'reference', previous: p_conf.current, sibling: conf.sibling}
       let hsh = await oracle.hash(obj)
-      res = `${pth}/${hsh}`;
+      res = ${pth}/${hsh};
 
       await oracle.fs.write(res, JSON.stringify(obj))
       p_conf.current = res
-      await oracle.fs.write(`${pth}/.config`, JSON.stringify(p_conf))
-      
+      await oracle.fs.write(${pth}/.config, JSON.stringify(p_conf))
+
       conf.sibling = res;
-      await oracle.fs.write(`${this.path}/.config`, JSON.stringify(conf))
+      await oracle.fs.write(${this.path}/.config, JSON.stringify(conf))
     }else {
       res = await this.persist(content, {...options })
     }
@@ -52,14 +52,14 @@ class Folder extends Storage{
 
   read =async (options={})=>{
     let res = await this.retrieve(options)
-    
+
     return res;
   }
 
   write_config = async (config, options={})=>{
     return await this.persist(config, {...options, config: true, })
   }
-  
+
   add_config = async (config, options={})=>{
     let result;
 
@@ -72,6 +72,14 @@ class Folder extends Storage{
         }
         result = await this.write_config(config)
         break;
+      case 'adm':
+        let adm_chain = await this.chain(config.location)
+        config.props = await this.add_config(config.props)
+        for (let c=0; c< config.children.length; c++){
+          config.children[c] = await this.add_config(config.children[c])
+        }
+        result = await adm_chain.write_config(config)
+        break;
       case 'class':
         let class_chain = await this.chain(config.name)
         for (let name in config.methods){
@@ -86,7 +94,7 @@ class Folder extends Storage{
           config.parameters[p] = await fn_chain.add_config(config.parameters[p])
         }
         for (let b=0; b< config.body.length; b++){
-          
+
           config.body[b] = await fn_chain.add_config(config.body[b])
         }
         result = await fn_chain.write_config(config)
@@ -125,7 +133,7 @@ class Folder extends Storage{
         break;
       case 'assignment':
         let ass_chain = await this.chain(config.identifier)
-        
+
         config.value = await ass_chain.add_config(config.value);
 
         result = await ass_chain.write_config(config)
@@ -137,7 +145,7 @@ class Folder extends Storage{
           config.iterator = await this.add_config(config.iterator)
           config.update = await this.add_config(config.update)
         }
-        
+
         for (let b=0; b< config.body.length; b++){
           config.body[b] = await this.add_config(config.body[b])
         }
@@ -161,7 +169,7 @@ class Folder extends Storage{
         }
         if(config.assignment)
           config.assignment = await nest_chain.add_config(config.assignment)
-        
+
         result = await nest_chain.write_config(config)
         break;
       default: 
@@ -189,7 +197,7 @@ class Folder extends Storage{
         }else if (['break', 'continue'].includes(config.type)){
           result = config;
         }
-      
+
     }
 
     return result;

package/Objects/Manager.js

@@ -10,6 +10,7 @@ class Manager {
     this.name = name;
     this.options = options || {};
 
+    this.compiler = options.compiler;
     this.trinity = options.trinity;
     this.sync_server = options.sync_server;
     if (this.sync_server && !this.sync_server.domain) {
@@ -33,7 +34,7 @@ class Manager {
 
     this.post_request = post_request;
 
-    await this.oracle.sync()
+    await this.oracle.sync();
     await this.repository.sync(this.name);
   };
 
@@ -50,9 +51,9 @@ class Manager {
     return account;
   };
 
-  get_account = name=>{
-    return this.accounts[name]
-  }
+  get_account = (name) => {
+    return this.accounts[name];
+  };
 }
 
 export default Manager;

package/Objects/Virtual_machine.js

@@ -45,8 +45,8 @@ class Virtual_machine extends Callable {
 
       if(line){
         if (line.type === 'instance'){
-          let classifier = await line.get('__classifier__')
-          
+          let classifier = await line.get('_classifier_')
+
           caught = err === classifier
           if (config.alias){
             let conf = await this.read_config(config.alias);
@@ -54,7 +54,7 @@ class Virtual_machine extends Callable {
             await this.execute({...conf, value: {type: 'address', value: line.value.path}}, {chain, hash})
           }
 
-          
+
         }else if(!line.type){
           caught = err.endsWith(line.value.name)
         }
@@ -89,7 +89,7 @@ class Virtual_machine extends Callable {
         }else if (line.error){
           if (config.type === 'trycatch'){
             let res = !config.caught && await this.handle_error(line, {chain, config})
-            
+
             if(!res){
               result = line
             }
@@ -117,15 +117,15 @@ class Virtual_machine extends Callable {
 
     switch (config.type) {
       case "module":
-        await this.execute_body(config.body, {chain, config})
-        
+        result = await this.execute_body(config.body, {chain, config})
+
         break;
       case "class":
         if (call_config) {
           let instance_chain = await chain.chain(call_config.location);
           let object = {
-            content: `[${config.name}]`,
-            __classifier__: config.address,
+            content: [${config.name}],
+            _classifier_: config.address,
             uid: this.gen_uid(),
           };
           for (let name in config.methods) {
@@ -135,14 +135,28 @@ class Virtual_machine extends Callable {
           let res = await instance_chain.write(object, { is_instance: true });
           result = { type: "address", value: res };
 
-          if (object.__init__) {
+          if (object._init_) {
             await this.execute(
-              { ...call_config, object: result, identifier: object.__init__ },
+              { ...call_config, object: result, identifier: object._init_ },
               { chain }
             );
           }
         }
         break;
+      case 'adm':
+        let props = await this.execute(config.props, {chain})
+        if(config.name.includes('/')){
+          result = await this.execute({
+            type:'call',
+            identifier: config.name,
+            arguments: [{...props, position: 0}],
+            location: config.location
+          }, {chain})
+        }else {
+          result = await this.native_components(config, chain)
+          result = await this.parse_aircode(result, {config, chain})
+        }
+        break
       case "function":
         if (call_config) {
           let fn_chain = await chain.chain(config.address);
@@ -201,7 +215,7 @@ class Virtual_machine extends Callable {
             value = { type: "address", value };
           result = await ass_chain.write(value, { hash });
         }
-        
+
         break;
       case "call":
         if (config.identifier.type === "nest") {
@@ -237,7 +251,7 @@ class Virtual_machine extends Callable {
         let cond = await this.execute(config.condition, {chain , cloth: true})
         while(await cond.literal()){
           result = await this.execute_body(config.body, {config, chain})
-          
+
           if (result && result.interrupt_loop){
             if (result.interrupt_loop === 'break'){
               result = null  
@@ -251,7 +265,7 @@ class Virtual_machine extends Callable {
           }
           cond = await this.execute(config.condition, {chain , cloth: true})
         }
-        
+
         break
       case 'trycatch':
         result = await this.execute_body(config.try_body, {chain, config})
@@ -268,7 +282,7 @@ class Virtual_machine extends Callable {
           });
           if (await pred.literal()) {
             result = await this.execute_body(block.body, {chain, config})
-            
+
             break;
           }
         }
@@ -300,6 +314,11 @@ class Virtual_machine extends Callable {
           } else {
             let res = await this.execute(nst, { chain, cloth: true });
             let prop = await res.literal();
+
+            if(prev.type === 'address'){
+              let conf = await this.resolve_address(prev.value)
+              prev = await this.cloth_content(conf)
+            }
             prev = await prev.get(prop, {obj: res, config: nst, chain});
           }
         }
@@ -332,7 +351,7 @@ class Virtual_machine extends Callable {
           let res = await var_chain.read({ sibling: true });
           if (!res) {
             res = await this.account.manager.oracle.fs.read(
-              `${var_chain.path}/.config`
+              ${var_chain.path}/.config
             );
             res = { type: "address", value: res.current };
           }
@@ -340,7 +359,7 @@ class Virtual_machine extends Callable {
         } else if (config.type === "reference") {
           let oracle = this.account.manager.oracle;
           let i_chain = await chain.chain(config.value);
-          let conf = await oracle.fs.read(`${i_chain.path}/.config`);
+          let conf = await oracle.fs.read(${i_chain.path}/.config);
           result = { type: "address", value: conf.current };
         }else if (['continue', 'break'].includes(config.type)){
           result = {interrupt_loop: config.type}

package/callables/functions/render.js

@@ -0,0 +1,24 @@
+const render = async (args, { vm, config, chain }) => {
+  let { object } = args;
+
+  let res = await object.get("render");
+  if (!res) return null;
+
+  let result = await vm.execute(
+    {
+      type: "call",
+      identifier: {
+        type: "address",
+        value: res,
+        object: object.value.path,
+      },
+      arguments: [],
+      location: config.location,
+    },
+    { chain }
+  );
+
+  return result;
+};
+
+export default render;

package/callables/register.js

@@ -2,6 +2,7 @@ import twain from "./functions/twain";
 import display from "./functions/display";
 import net from "godprotocol/callables/functions/net";
 import quit from "godprotocol/callables/functions/exit";
+import render from "./functions/render";
 
 const register = async (account) => {
   let set = account.vm.set;
@@ -23,7 +24,11 @@ const register = async (account) => {
   set("net", {
     callable: net,
     config: {
-      parameters: [{ name: "server", position: 0 }, { name: "path", position: 0 }, { name: "payload", position: 0 }],
+      parameters: [
+        { name: "server", position: 0 },
+        { name: "path", position: 0 },
+        { name: "payload", position: 0 },
+      ],
     },
   });
 
@@ -33,6 +38,13 @@ const register = async (account) => {
       parameters: [{ name: "code", position: 0 }],
     },
   });
+
+  set("render", {
+    callable: render,
+    config: {
+      parameters: [{ name: "object", position: 0 }],
+    },
+  });
 };
 
 export default register;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "godprotocol",
-  "version": "1.1.3",
+  "version": "1.1.32",
   "description": "A distributed computing environment",
   "main": "Index.js",
   "scripts": {

package/utils/create_server.js

@@ -1,44 +1,68 @@
 import https from "https";
-import fs from "fs";
+import http from "http";
 
 let PORT = Number(process.env.PORT) || 1408;
 
 const handle_routes = (req, res, manager, app) => {
   let data = "";
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type");
 
+  if (req.method === "OPTIONS") {
+    res.writeHead(204, {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Headers": "Content-Type",
+      "Access-Control-Allow-Methods": "POST, GET, OPTIONS",
+    });
+    res.end();
+    return;
+  }
+
+  if (['/create_account', '/load', '/run', '/parse'].includes(req.url)){
+    req.on("data", (chunk) => {
+      data += chunk;
+    });
   
-  req.on("data", (chunk) => {
-    data += chunk;
-  });
+    req.on("end", async () => {
+      if (!data) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Request body cannot be empty" }));
+        return;
+      }
 
-  req.on("end", async () => {
-    data = JSON.parse(data)
-    let result;
-    if (req.url === '/create_account'){
-      result = await manager.add_account(data.name, data.options)
-      res.end(JSON.stringify(result.stringify()))
-    }else if(req.url === '/load'){
-      let account = await manager.get_account(data.account);
-      result = await account.load(data)
-      res.end(JSON.stringify(result))
-    }else if(req.url === '/run'){
-      let account = await manager.get_account(data.account);
-      result = await account.run(data)
-      
-      res.end(result? JSON.stringify(result): JSON.stringify({done: true}))
-    }else if(req.url === '/parse'){
-      let account = await manager.get_account(data.account);
-      result = await account.parse(data)
-      
-      res.end(result? JSON.stringify(result): JSON.stringify({done: true}))
-    }
-  });
+      data = JSON.parse(data)
+      let result;
 
-  req.on("error", (e) => {
-    console.log('hm')
-    // res.writeHead(500, { "Content-Type": "application/json" });
-    res.end(JSON.stringify({ status: "error", error_message: e.message }));
-  });
+      if (req.url === '/create_account'){
+        result = await manager.add_account(data.name, data.options)
+        res.end(JSON.stringify(result.stringify()))
+      }else if(req.url === '/load'){
+        let account = await manager.get_account(data.account);
+        result = await account.load(data)
+        res.end(JSON.stringify(result))
+      }else if(req.url === '/run'){
+        let account = await manager.get_account(data.account);
+        result = await account.run(data)
+        
+        res.writeHead(200, { "Content-type": "application/json" });
+
+        res.end(result? JSON.stringify(result): JSON.stringify({done: true}))
+      }else if(req.url === '/parse'){
+        let account = await manager.get_account(data.account);
+        result = await account.parse(data)
+        
+        res.end(result? JSON.stringify(result): JSON.stringify({done: true}))
+      }
+    });
+  
+    req.on("error", (e) => {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "error", error_message: e.message }));
+    });
+  }else if (app){
+    app(req, res);
+  }
+  
 };
 
 const create_server = async (settings) => {
@@ -48,11 +72,12 @@ const create_server = async (settings) => {
 
     port = port || PORT;
     
-    let server = https.createServer(
-      {
-        key: fs.readFileSync(`${__dirname}/server.key`),
-        cert: fs.readFileSync(`${__dirname}/server.cert`),
-      },
+    // console.log(__dirname)
+    let server = http.createServer(
+      // {
+      //   key: fs.readFileSync(`${__dirname}/server.key`),
+      //   cert: fs.readFileSync(`${__dirname}/server.cert`),
+      // },
       (req, res) => handle_routes(req, res, manager, app)
     );
 

package/utils/vm_utils.js

@@ -9,95 +9,203 @@ import Bool from "../Datatypes/bool";
 import Instance from "../Datatypes/instance";
 import Func from "../Datatypes/func";
 import Cls from "../Datatypes/cls";
+import { ops } from "./ops";
 
 class Vm_utils {
   constructor() {
+    this.ops = ops;
     this.literal_methods = {
-      number: ['add','sub','div','mul', 'exp', 'floordiv', 'eq', "ne", "lt", 'gt', 'gte', 'lte', 'neg', 'abs', 'and', 'or', 'xor', 'lshift', 'rshift', 'invert'].map(i=>`__${i}__`).concat(['to_int', 'to_float', 'to_string', 'sqrt', 'log', 'sin', 'sinh', 'tanh', 'cosh', 'atanh', 'acosh', 'asinh', 'atan', 'acos', 'asin', 'cos', 'tan', 'round', 'factorial', 'ceil', 'floor', 'is_prime', 'is_even', 'is_odd', 'is_perfect_square', 'to_degrees', 'to_radians']),
-      string: ['upper','lower','title','slice', 'concat', 'find', 'includes', 'index', 'trim', 'split', 'padstart', 'padend', 'repeat', 'replace', 'startswith', 'endswith', 'count', 'length', 'reverse', 'is_numeric', 'is_empty', 'is_blank', 'charcode'],
-      array:[
-        'push', 'pop', 'length', 'run', 'copy', 'deepcopy', 'extend', 'slice', 'index', 'includes', 'replace', 'map', 'find', 'filter', 'padstart', 'padend', 'clear', 'to_string', 'reverse', 'repeat', 'join', 'splice'
+      number: [
+        "add",
+        "sub",
+        "div",
+        "mul",
+        "exp",
+        "floordiv",
+        "eq",
+        "ne",
+        "lt",
+        "gt",
+        "gte",
+        "lte",
+        "neg",
+        "abs",
+        "and",
+        "or",
+        "xor",
+        "lshift",
+        "rshift",
+        "invert",
+      ]
+        .map((i) => `__${i}__`)
+        .concat([
+          "to_int",
+          "to_float",
+          "to_string",
+          "sqrt",
+          "log",
+          "sin",
+          "sinh",
+          "tanh",
+          "cosh",
+          "atanh",
+          "acosh",
+          "asinh",
+          "atan",
+          "acos",
+          "asin",
+          "cos",
+          "tan",
+          "round",
+          "factorial",
+          "ceil",
+          "floor",
+          "is_prime",
+          "is_even",
+          "is_odd",
+          "is_perfect_square",
+          "to_degrees",
+          "to_radians",
+        ]),
+      string: [
+        "upper",
+        "lower",
+        "title",
+        "slice",
+        "concat",
+        "find",
+        "includes",
+        "index",
+        "trim",
+        "split",
+        "padstart",
+        "padend",
+        "repeat",
+        "replace",
+        "startswith",
+        "endswith",
+        "count",
+        "length",
+        "reverse",
+        "is_numeric",
+        "is_empty",
+        "is_blank",
+        "charcode",
+      ],
+      array: [
+        "push",
+        "pop",
+        "length",
+        "run",
+        "copy",
+        "deepcopy",
+        "extend",
+        "slice",
+        "index",
+        "includes",
+        "replace",
+        "map",
+        "find",
+        "filter",
+        "padstart",
+        "padend",
+        "clear",
+        "to_string",
+        "reverse",
+        "repeat",
+        "join",
+        "splice",
       ],
       twain: [
-        'entries', 'get', 'set', 'keys', 'clear', 'is_empty', 'values', 'copy', 'deepcopy', 'remove'
-      ]
-    }
+        "entries",
+        "get",
+        "set",
+        "keys",
+        "clear",
+        "is_empty",
+        "values",
+        "copy",
+        "deepcopy",
+        "remove",
+      ],
+    };
 
-    this.datatypes = ['string', 'number', 'void', 'boolean', 'array', 'twain']
+    this.datatypes = ["string", "number", "void", "boolean", "array", "twain"];
   }
 
-  gen_uid = ()=>{
-    return `_${Math.random().toString().replace('.', '')}_${Date.now()}`
-  }
+  gen_uid = () => {
+    return `_${Math.random().toString().replace(".", "")}_${Date.now()}`;
+  };
 
-  parse_dynamic = async(literal, options={})=>{
-    let {chain, config} = options;
+  parse_dynamic = async (literal, options = {}) => {
+    let { chain, config } = options;
 
     let aircode = this.account.aircode;
-    let sequence = aircode.to_sequence(JSON.stringify(literal), chain.physical_address)
+    let sequence = aircode.to_sequence(
+      JSON.stringify(literal),
+      chain.physical_address
+    );
 
     let res = await chain.add_config(sequence[0].body[0]);
-    let address = await this.execute(res, {chain})
+    let address = await this.execute(res, { chain });
 
     return address;
-  }
+  };
 
-  resolve_addr = (addr)=>{
-    if (!addr)return addr
+  resolve_addr = (addr) => {
+    if (!addr) return addr;
 
-    if (addr.startsWith('@')){
-      addr = `${this.account.physical_address}/${addr.slice(2)}`
+    if (addr.startsWith("@")) {
+      addr = `${this.account.physical_address}/${addr.slice(2)}`;
     }
 
     return addr;
-  }
+  };
 
-  cloth_object = async addr=>{
-    
-  }
+  cloth_object = async (addr) => {};
 
-  cloth_content = async(content, options)=>{
+  cloth_content = async (content, options) => {
     let obj;
 
-    if (content instanceof Instance)return content;
-    
-    switch(content.type){
-      case 'number':
-        obj = new Num(content, this.account)
+    if (content instanceof Instance) return content;
+
+    switch (content.type) {
+      case "number":
+        obj = new Num(content, this.account);
+        break;
+      case "string":
+        obj = new Str(content, this.account);
         break;
-      case 'string':
-        obj = new Str(content, this.account)
+      case "boolean":
+        obj = new Bool(content, this.account);
         break;
-      case 'boolean':
-        obj = new Bool(content, this.account)
+      case "void":
+        obj = new Voi(content, this.account);
         break;
-      case 'void':
-        obj = new Voi(content, this.account)
+      case "array":
+        obj = new Arr(content, this.account);
         break;
-      case 'array':
-        obj = new Arr(content, this.account)
-        break
-      case 'twain':
-        obj = new Twa(content, this.account)
+      case "twain":
+        obj = new Twa(content, this.account);
         break;
-      case 'instance':
-        obj = new Instance(content, this.account)
+      case "instance":
+        obj = new Instance(content, this.account);
         break;
-      case 'function':
-        obj = new Func(content, this.account)
+      case "function":
+        obj = new Func(content, this.account);
         break;
-      case 'class':
-        obj = new Cls(content, this.account)
+      case "class":
+        obj = new Cls(content, this.account);
         break;
       default:
-        if (content.type === 'address'){
-          obj = new Func(content, this.account)
-        }else obj = content
-        // console.log(content, 'uh')
+        if (content.type === "address") {
+          obj = new Func(content, this.account);
+        } else obj = content;
+      // console.log(content, 'uh')
     }
 
-    return await obj.sync(options)
-  }
+    return await obj.sync(options);
+  };
 }
 
 export default Vm_utils;