godprotocol 1.1.2 → 1.1.31

package/Objects/Virtual_machine.js

@@ -5,25 +5,374 @@ class Virtual_machine extends Callable {
     super();
 
     this.account = account;
+    this.contexts = new Array();
   }
 
+  read_config = async (addr, options = {}) => {
+    if (typeof addr !== "string") {
+      return addr;
+    }
+    let oracle = this.account.manager.oracle;
+
+    let result = await oracle.read(addr, { current: true, config: true });
+
+    return result;
+  };
+
   sync = async () => {};
 
-  execute = async (instruction) => {
-    let { opcode, payload } = this.parse_instruction(instruction);
+  errors = ['MathError', 'ZeroDivision', 'RuntimeError']
+
+  handle_error = async(errline, {config, chain})=>{
+    let {objects} = config;
+    for (let o=0; o< objects.length; o++){
+      let err = objects[o], caught, line = errline;
+
+      if (line.value.type === 'variable'){
+        if (this.errors.includes(line.value.value)){
+          line = {value: {name: line.value.value}}
+        }else {
+          let res= await this.execute(line.value, {chain, caught: true})
+          if (res.type === 'address'){
+            res = await this.resolve_address(res.value)
+          }
+          line = res;
+        }
+      }else if(typeof line.value === 'string' || line.value.type){
+        let res = await this.execute(line.value, {chain, caught: true, cloth:true})
+        line = res;
+      }
+
+      if(line){
+        if (line.type === 'instance'){
+          let classifier = await line.get('_classifier_')
+
+          caught = err === classifier
+          if (config.alias){
+            let conf = await this.read_config(config.alias);
+            let hash = await this.account.manager.oracle.hash(conf);
+            await this.execute({...conf, value: {type: 'address', value: line.value.path}}, {chain, hash})
+          }
+
+
+        }else if(!line.type){
+          caught = err.endsWith(line.value.name)
+        }
+      }
+
+      if(caught){
+        await this.execute_body(config.catch_body, {chain, config: {...config, caught: true}})
+        return true;
+      }
+    }
+  }
+
+  execute_body = async (body, options)=>{
+    let {config, chain} = options;
+    let result;
+    for (let b=0; b< body.length; b++){
+      let line = body[b];
+
+      line = await this.execute(line, {...options, line});
+
+      if (line){
+        if (line.interrupt_loop){
+          result =line
+          break;
+        }
+        else if (line.done){
+          result = line.value;
+          break;
+        }else if (line.exit){
+          result = line;
+          break
+        }else if (line.error){
+          if (config.type === 'trycatch'){
+            let res = !config.caught && await this.handle_error(line, {chain, config})
+
+            if(!res){
+              result = line
+            }
+            break
+          }else {
+            result = line;
+            break
+          }
+        }
+        result = line
+      }
+    }
+
+    return result;
+  }
+
+  execute = async (config, options = {}) => {
+    let prev_config = config
+    config = await this.read_config(config);
+    // console.log(config, 'EXE')
 
-    let callable = await this.callable(opcode);
+    let { chain, cloth, hash, obj, call_config } = options,
+      result;
+    hash = hash || (await this.account.manager.oracle.hash(config));
+
+    switch (config.type) {
+      case "module":
+        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,
+            uid: this.gen_uid(),
+          };
+          for (let name in config.methods) {
+            let addr = config.methods[name];
+            object[name] = addr;
+          }
+          let res = await instance_chain.write(object, { is_instance: true });
+          result = { type: "address", value: res };
+
+          if (object._init_) {
+            await this.execute(
+              { ...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);
+          let params = new Array();
+          for (let a = 0; a < call_config.arguments.length; a++) {
+            let arg = call_config.arguments[a];
+
+            for (let p = 0; p < config.parameters.length; p++) {
+              let param = await this.read_config(config.parameters[p]);
+
+              if (arg.identifier) {
+              } else {
+                if (p === arg.position) {
+                  param.hash = await this.account.manager.oracle.hash(param);
+                  param.value = arg;
+                  params.push(param);
+                }
+              }
+            }
+          }
+          for (let p = 0; p < params.length; p++) {
+            let param = params[p];
+
+            await this.execute(param, { chain: fn_chain, hash: param.hash });
+          }
+          if (call_config.object) {
+            let conf = {
+              type: "assignment",
+              identifier: "this",
+              value: call_config.object,
+            };
+            let r = await fn_chain.add_config(conf);
+
+            await this.execute(r, { chain: fn_chain });
+          }
+
+          result = await this.execute_body(config.body, {chain: fn_chain, config})
+        }else result = {type:'address', value: prev_config}
+
+        break;
+      case "return":
+        let ret_value = await this.execute(config.output, { chain });
+
+        result = { done: true, value: ret_value };
+        break;
+      case "assignment":
+        let ass_chain = await chain.chain(config.identifier);
+        let value = await this.execute(config.value, { chain: ass_chain });
+
+        if (value && value.error){
+          result = value
+        }else {
+          if (value && value.account) {
+            value = { type: "address", value: value.value.path };
+          } else if (typeof value === "string")
+            value = { type: "address", value };
+          result = await ass_chain.write(value, { hash });
+        }
+
+        break;
+      case "call":
+        if (config.identifier.type === "nest") {
+          config.identifier = await this.execute(config.identifier.address, {
+            chain,
+          });
+        }
+        for (let a = 0; a < config.arguments.length; a++) {
+          let arg = await this.read_config(config.arguments[a]);
+
+          let obj = await this.execute(
+            arg.type === "assignment" ? arg.value : arg,
+            { chain }
+          );
+          if (obj.account) {
+            obj = { type: "address", value: obj.value.path };
+          }
+          if (arg.type === "assignment") {
+            obj.identifier = arg.identifier;
+          }
+          obj.position = a;
+          config.arguments[a] = obj;
+        }
+
+        result = await this.execute_call(config, { chain , obj});
+
+        break;
+      case 'loop':
+        let {loop_type } = config;
+        if (loop_type === 'for'){
+          await this.execute(config.iterator, {chain})
+        }
+        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  
+              break;
+            } else{
+              result = null
+            }
+          }
+          if(loop_type === 'for'){
+            await this.execute(config.update, {chain})
+          }
+          cond = await this.execute(config.condition, {chain , cloth: true})
+        }
+
+        break
+      case 'trycatch':
+        result = await this.execute_body(config.try_body, {chain, config})
+        break;
+      case 'raise':
+        result = {error: true, value: config.object}
+        break;
+      case "condition":
+        for (let i = 0; i < config.blocks.length; i++) {
+          let block = config.blocks[i];
+          let pred = await this.execute(block.predicate, {
+            chain,
+            cloth: true,
+          });
+          if (await pred.literal()) {
+            result = await this.execute_body(block.body, {chain, config})
+
+            break;
+          }
+        }
+        break;
+      case "nest":
+        let prev = await this.execute(config.nests[0], { chain, cloth: true }),
+          pprev;
+
+        for (
+          let n = 1;
+          n < config.nests.length - (config.assignment ? 1 : 0);
+          n++
+        ) {
+          let nst = await this.read_config(config.nests[n]);
+          pprev = prev;
+
+          if (nst.type === "call") {
+            let conf =prev.type === 'function'? prev.value: await prev.get(nst.identifier, {obj: prev, config: nst, chain});
+            if (!conf) await this.throw_error();
+            nst.object = { value: prev.value.path, type: "address" };
+            conf.prev_name = nst.identifier
+            prev = await this.execute(
+              { ...nst, identifier: conf.type ==='function'?conf.address:conf },
+              { chain, cloth: true, obj:prev }
+            );
+            if(prev && prev.error){
+              break;
+            }
+          } 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});
+          }
+        }
+        if (config.assignment) {
+          let ass = await this.execute(config.assignment, { chain });
+          let last = config.nests.slice(-1)[0];
+          last = await this.execute(last, { chain, cloth: true });
+
+          await prev.set(last, ass);
+        }
+
+        if (prev && prev.type !== "address") {
+          if(!prev.error)
+          prev = {
+            value: prev.value ? prev.value.path : prev,
+            type: "address",
+            object: prev.value ? null : pprev.value.path,
+          };
+        }
+        result = prev;
+        break;
+      default:
+        if (["number", "string", "boolean", 'twain', 'void', 'array'].includes(config.type)) {
+          result = await this.instantiate(config, { chain, hash });
+          result = { type: "address", value: result };
+        } else if (config.type === "address") {
+          result = config;
+        } else if (config.type === "variable") {
+          let var_chain = await chain.chain(config.location);
+          let res = await var_chain.read({ sibling: true });
+          if (!res) {
+            res = await this.account.manager.oracle.fs.read(
+              ${var_chain.path}/.config
+            );
+            res = { type: "address", value: res.current };
+          }
+          result = res;
+        } 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);
+          result = { type: "address", value: conf.current };
+        }else if (['continue', 'break'].includes(config.type)){
+          result = {interrupt_loop: config.type}
+        }
+    }
 
-    if (!callable) {
-      return await this.stderr({
-        name: "runtime_error",
-        message: `opcode:${opcode} is not set.`,
-      });
+    if (result && cloth) {
+      if ( result.type === "address" && result.value.includes('/')) {
+        result = await this.resolve_address(result.value);
+      }
+      if (result && !result.error) result = await this.cloth_content(result);
     }
-    let call = callable.callable;
-    let args = await this.parse_arguments(payload, callable.config);
 
-    let result = await call(args);
     return result;
   };
 }

package/callables/functions/display.js

@@ -1,3 +1,17 @@
-const display = async (args) => {};
+const display = async (args) => {
+  let {data}= args;
+  
+  if(!Array.isArray(data)) data = [data]
+
+  let lit= new Array()
+  for(let d =0; d < data.length; d++){
+    let tum = data[d]
+    lit.push(await tum.literal())
+  }
+
+  console.log(...lit)
+
+  return 0
+};
 
 export default display;

package/callables/functions/exit.js

@@ -0,0 +1,10 @@
+const quit = async(args, vm)=>{
+  let {code} = args;
+  if (code) code = await code.literal()
+
+  console.log(`Program exit with code:${code ||0}`)
+
+  return {exit: true, code}
+}
+
+export default quit

package/callables/functions/net.js

@@ -0,0 +1,27 @@
+import { post_request } from "../../utils/services";
+
+const net = async(args, vm, options={})=>{
+  let {chain, config} = options;
+  let {server, path, payload, callback} = args;
+  
+  server = await server.literal()
+  path = await path.literal()
+  if (!path.startsWith('/')) path = `/${path}`
+
+  payload = payload && await payload.literal()
+
+  let result;
+  if(callback){
+
+  }else {
+    result = await post_request({options: {hostname: server.ip, port: server.port, path}, data: payload})
+    
+    result = await vm.parse_dynamic(result, {chain, config})
+  }
+  
+
+  return result;
+}
+
+
+export default net;

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/functions/twain.js

@@ -0,0 +1,11 @@
+const twain = async(args, vm)=>{
+  if (!args.instance){
+    return await vm.stderr({name: 'Name_error'})
+  }
+  let instance_object = args.instance;
+
+  instance_object.is_literal = true;
+  return instance_object
+}
+
+export default twain;

package/callables/register.js

@@ -1,20 +1,48 @@
-import assign from "./functions/assign";
+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;
 
-  set("assign", {
-    callable: assign,
+  set("display", {
+    callable: display,
     config: {
-      parameters: [{ name: "assignment", position: 0 }],
+      parameters: [{ name: "data", position: 0, spread: true }],
     },
   });
 
-  set("display", {
-    callable: display,
+  set("Twain", {
+    callable: twain,
     config: {
-      parameters: [{ name: "data", position: 0, spread: true }],
+      parameters: [{ name: "instance", position: 0 }],
+    },
+  });
+
+  set("net", {
+    callable: net,
+    config: {
+      parameters: [
+        { name: "server", position: 0 },
+        { name: "path", position: 0 },
+        { name: "payload", position: 0 },
+      ],
+    },
+  });
+
+  set("exit", {
+    callable: quit,
+    config: {
+      parameters: [{ name: "code", position: 0 }],
+    },
+  });
+
+  set("render", {
+    callable: render,
+    config: {
+      parameters: [{ name: "object", position: 0 }],
     },
   });
 };

package/package.json

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

package/utils/create_server.js

@@ -1,30 +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");
 
-  req.on("data", (chunk) => {
-    data += chunk;
-  });
+  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;
+  }
 
-  req.on("end", async () => {
-    if (req.url === "/sync") {
-      data = JSON.parse(data);
+  if (['/create_account', '/load', '/run', '/parse'].includes(req.url)){
+    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;
+      }
 
-      let response = await manager.oracle.add_server(data);
+      data = JSON.parse(data)
+      let result;
 
-      console.log(response, "hello");
-      res.end(JSON.stringify(response));
-    }
-  });
+      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" });
 
-  req.on("error", (e) => {
-    // res.writeHead(500, { "Content-Type": "application/json" });
-    res.end(JSON.stringify({ status: "error", error_message: e.message }));
-  });
+        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) => {
@@ -33,12 +71,13 @@ const create_server = async (settings) => {
     let { port, app, manager } = 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/hash.js

@@ -0,0 +1,18 @@
+const crypto = require("crypto");
+
+const hash = (data, alg) => {
+  let hash = crypto.createHash(alg || "sha256");
+
+  hash.update(data);
+
+  let result = hash.digest("hex");
+
+  if (alg){
+    if (!isNaN(Number(result[0])))
+    result = `_${result.slice(0, -1)}`;
+  }
+
+  return result;
+};
+
+export { hash };

package/utils/ops.js

@@ -0,0 +1,17 @@
+let ops = [
+  { name: "add", sign: "+" },
+  { name: "mul", sign: "*" },
+  { name: "sub", sign: "-" },
+  { name: "div", sign: "/" },
+  { name: "mod", sign: "%" },
+  { name: "floordiv", sign: "#" },
+  { name: "exp", sign: "**" },
+  { name: "eq", sign: "==" },
+  { name: "ne", sign: "!=" },
+  { name: "gt", sign: ">" },
+  { name: "lt", sign: "<" },
+  { name: "lte", sign: "<=" },
+  { name: "gte", sign: ">=" },
+];
+
+export { ops };