godprotocol 1.2.25 → 1.2.26

package/package.json

@@ -1,40 +1,47 @@
 {
   "name": "godprotocol",
-  "version": "1.2.25",
-  "description": "A distributed computing environment",
+  "version": "1.2.26",
+  "description": "A distributed computing environment for Web 4.0 — integrating AI, decentralisation, and virtual computation.",
   "main": "Index.js",
+  "type": "module",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "start": "nodemon -r esm Index.js"
+    "start": "nodemon Index.js",
+    "dev": "node Index.js",
+    "test": "echo \"No test specified\" && exit 0"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/immanuel-savvy/GodProtocol.git"
   },
   "keywords": [
-    "decentralise",
-    "distribute",
+    "godprotocol",
+    "distributed",
+    "decentralized",
     "web4",
     "ai",
+    "blockweb",
+    "virtual-machine",
+    "loader-sequence",
     "ar",
-    "vr",
-    "virtual-machine"
+    "vr"
   ],
-  "author": "Savvy",
+  "author": "Savvy <contact@yourdomain.com>",
   "license": "ISC",
   "bugs": {
     "url": "https://github.com/immanuel-savvy/GodProtocol/issues"
   },
-  "type": "module",
   "homepage": "https://github.com/immanuel-savvy/GodProtocol#readme",
   "dependencies": {
-    "crypto": "^1.0.1",
-    "fs": "^0.0.1-security",
-    "generalised-datastore": "latest",
-    "aircode4": "latest"
+    "aircode4": "latest",
+    "generalised-datastore": "latest"
   },
   "devDependencies": {
-    "esm": "^3.2.25",
     "nodemon": "^3.1.7"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
   }
 }

package/utils/vm_utils.js

@@ -16,103 +16,116 @@ import { hash } from "godprotocol/utils/hash.js";
 class Vm_utils {
   constructor() {
     this.ops = ops;
-   
+
     this.datatypes = ["string", "number", "void", "boolean", "array", "twain"];
   }
 
-  gen_location=(addr)=>{
-    return `${addr|| this.account.physical_address}/${this.gen_uid(true)}`
-  }
+  gen_location = (addr) => {
+    return `${addr || this.account.physical_address}/${this.gen_uid(true)}`;
+  };
 
-  error_instance = async(err_payload, alias)=>{
-    let {chain, manager} = this.account;
-    let res = await this.instantiate({type: 'error', ...err_payload}, {chain})
-    if (alias){
-      await (await manager.ds.folder(alias.location)).write(res)
+  error_instance = async (err_payload, alias) => {
+    let { chain, manager } = this.account;
+    let res = await this.instantiate(
+      { type: "error", ...err_payload },
+      { chain }
+    );
+    if (alias) {
+      await (await manager.ds.folder(alias.location)).write(res);
     }
-  }
+  };
 
-  variable = async(address, {chain, config, obj})=>{
+  variable = async (address, { chain, config, obj }) => {
     let result;
-    let chn = await chain.chain(address)
-    let fold = await chn.folder()
+    let chn = await chain.chain(address);
+    let fold = await chn.folder();
 
-    if(config && config._id && config.type === 'reference'){
+    if (config && config._id && config.type === "reference") {
       result = {
-        type: 'address',
-        value: address, 
-        _id: config._id
-      }
-      if (config.object) result.object = config.object
-    }else result = await fold.readone(config && config._id?{_id: config._id}: null)
-
-    if (obj) result = await this.cloth(result)
-
-    return result
-}
+        type: "address",
+        value: address,
+        _id: config._id,
+      };
+      if (config.object) result.object = config.object;
+    } else
+      result = await fold.readone(
+        config && config._id ? { _id: config._id } : null
+      );
+
+    if (obj) result = await this.cloth(result);
+
+    return result;
+  };
 
   gen_uid = (loc) => {
-    return `_${Math.random().toString().replace(".", "")}${loc ?'': '_'}${Date.now()}`;
+    return `_${Math.random().toString().replace(".", "")}${
+      loc ? "" : "_"
+    }${Date.now()}`;
   };
 
-  spread_properties = async(object, cls, {lists, benches})=>{
-    for (let m in cls.methods){
-      object.methods[m] = cls.methods[m]
+  spread_properties = async (object, cls, { lists, benches }) => {
+    for (let m in cls.methods) {
+      object.methods[m] = cls.methods[m];
     }
-    for(let p in cls.properties){
-      let prop = cls.properties[p]
-      let res = await this.nodelist(prop)
-      lists.push(...res)
+    for (let p in cls.properties) {
+      let prop = cls.properties[p];
+      let res = await this.nodelist(prop);
+      lists.push(...res);
       benches[p] = lists.length - 1;
     }
-  }
+  };
+
+  base_classes = async (
+    object,
+    config,
+    { inherited, lists, benches, chain }
+  ) => {
+    for (let b = 0; b < config.base_classes.length; b++) {
+      let blc = config.base_classes[b];
+      if (inherited.includes(blc.location)) continue;
 
-  base_classes = async (object, config, {inherited, lists, benches, chain})=>{
-    
-    for (let b=0; b< config.base_classes.length; b++){
-      let blc = config.base_classes[b]
-      if (inherited.includes(blc.location)) continue
+      let cls = await this.cloth(await this.variable(blc.location, { chain }), {
+        just_content: true,
+      });
 
-      let cls = await this.cloth(await this.variable(blc.location, {chain}), {just_content: true})
-      
-      await this.spread_properties(object, cls, {lists, benches})
+      await this.spread_properties(object, cls, { lists, benches });
 
       if (cls.base_classes.length)
-        await this.base_classes(object, cls, {inherited, chain})
+        await this.base_classes(object, cls, { inherited, chain });
     }
-  }
+  };
 
-  retrieve = async(object, o)=>{
+  retrieve = async (object, o) => {
     let obj, addr;
-    if (object.type === 'instance') {
+    if (object.type === "instance") {
       let cls = await this.cloth({
-        type:'function',
+        type: "function",
         address: object.cls,
         // _id: object.cls_id
-      })
-      addr = await cls.get_instance(object, true)
-      if (o){
-        obj = await this.cloth(addr)
+      });
+      addr = await cls.get_instance(object, true);
+      if (o) {
+        obj = await this.cloth(addr);
       }
-    } else if (['twain', 'array'].includes(object.type)) {
+    } else if (["twain", "array"].includes(object.type)) {
       obj = await this.cloth_content(object);
 
-      await obj.retrieve(object.entries || object.items)
+      await obj.retrieve(object.entries || object.items);
 
-      addr = await obj.to_address()
-    } else if (object.type === 'function') {
-      console.log(object, 'in here')
+      addr = await obj.to_address();
+    } else if (object.type === "function") {
+      console.log(object, "in here");
       // process.exit()
-      obj = object
-      addr = await object.to_address()
+      obj = object;
+      addr = await object.to_address();
     } else {
-      obj =  await this.cloth_content(object)
+      obj = await this.cloth_content(object);
 
-      addr = await obj.to_address()
+      addr = await obj.to_address();
     }
 
     return o ? obj : addr;
-  }
+  };
 
   parse_dynamic = async (literal, options = {}) => {
     let { chain, config } = options;
@@ -129,36 +142,36 @@ class Vm_utils {
     return address;
   };
 
-  folder = async(fold)=>{
+  folder = async (fold) => {
     return {
-      type: 'folder',
+      type: "folder",
       repo: fold.config.repo,
-      value: fold.address, 
-      _id: await this.hash(fold.address)
-    }
-  }
+      value: fold.address,
+      _id: await this.hash(fold.address),
+    };
+  };
 
-  base_val = async type=>{
+  base_val = async (type) => {
     let result;
-    
-    switch(type){
-      case 'string':
-        result = ''
+
+    switch (type) {
+      case "string":
+        result = "";
         break;
-      case 'number':
-        result = '0'
+      case "number":
+        result = "0";
         break;
-      case 'array':
-        result = []
+      case "array":
+        result = [];
         break;
-      case 'twain':
-        result = {}
+      case "twain":
+        result = {};
         break;
-      case 'boolean':
-        result = false
+      case "boolean":
+        result = false;
     }
-    return await this.typecast(result, type, true) 
-  }
+    return await this.typecast(result, type, true);
+  };
 
   resolve_addr = (addr) => {
     if (!addr) return addr;
@@ -170,34 +183,34 @@ class Vm_utils {
     return addr;
   };
 
-  typecast = async(obj, type)=>{
-    return obj
-  }
+  typecast = async (obj, type) => {
+    return obj;
+  };
 
-  _split_datapath = (datapath)=>{
-    datapath = datapath.split('/')
+  _split_datapath = (datapath) => {
+    datapath = datapath.split("/");
 
-    return [datapath.slice(0,-1).join('/'), datapath.slice(-1)[0]]
-  }
+    return [datapath.slice(0, -1).join("/"), datapath.slice(-1)[0]];
+  };
 
-  voided = async ()=>{
-    return await this.statics({type: 'void'})
-  }
+  voided = async () => {
+    return await this.statics({ type: "void" });
+  };
 
-  statics = async(config)=>{
-    let addr = `${this.account.physical_address}/__$STATICS/`
-    let folder = await this.account.manager.ds.folder(addr)
+  statics = async (config) => {
+    let addr = `${this.account.physical_address}/__$STATICS/`;
+    let folder = await this.account.manager.ds.folder(addr);
 
-    let value = config.type=== 'boolean'? config.value : 'void'
-    let _id = await this.hash(value)
-    await folder.write({type: config.type, value, _id })
+    let value = config.type === "boolean" ? config.value : "void";
+    let _id = await this.hash(value);
+    await folder.write({ type: config.type, value, _id });
 
     return {
       value: addr,
-      _id, 
-      type: 'address'
-    }
-  }
+      _id,
+      type: "address",
+    };
+  };
 
   err_objects = [
     "ZeroDivisionError",
@@ -207,59 +220,61 @@ class Vm_utils {
     "RuntimeError",
     "CompileError",
     "AssertionError",
-  ]
+  ];
 
-  cloth = async(address, options={})=>{
-    let {just_content} = options
+  cloth = async (address, options = {}) => {
+    let { just_content } = options;
     let content;
 
-    if (address.config){
+    if (address.config) {
       address = {
-        type: 'function',
-        _id: address._id, 
+        type: "function",
+        _id: address._id,
         address: address.value,
         value: address.value,
-      }
+      };
     }
-    
-    if (address.type === 'address'){
-      if (address.value.includes('/')){
-        let folder = await this.account.manager.ds.folder(address.value)
-        if (address.object){
-          folder = await folder.folder('.configs')
+
+    if (address.type === "address") {
+      if (address.value.includes("/")) {
+        let folder = await this.account.manager.ds.folder(address.value);
+        if (address.object) {
+          folder = await folder.folder(".configs");
         }
-        content = await folder.readone({_id: address._id})
-      }else if(address.object) {
-        content = {...address, type: 'function'}
+        content = await folder.readone({ _id: address._id });
+      } else if (address.object) {
+        content = { ...address, type: "function" };
       }
-    }else if(['function', 'class'].includes(address.type)) {
-      if (address._id && address._id === address.value){
-        content = address
-      }else {
-        let folder = await this.account.manager.ds.folder(`${address.address}`)
-        folder = await folder.folder('.configs')
-        
-        content = await folder.readone(address._id? {_id: address._id}: null)
+    } else if (["function", "class"].includes(address.type)) {
+      if (address._id && address._id === address.value) {
+        content = address;
+      } else {
+        let folder = await this.account.manager.ds.folder(`${address.address}`);
+        folder = await folder.folder(".configs");
+
+        content = await folder.readone(
+          address._id ? { _id: address._id } : null
+        );
       }
     }
 
-    if (just_content)
-      return content;
+    if (just_content) return content;
 
-    if (content){
-      content = await this.cloth_content(content)
-      content.address = address.value
-      if (address.is_literal && content.type === 'twain') content.is_literal = true
+    if (content) {
+      content = await this.cloth_content(content);
+      content.address = address.value;
+      if (address.is_literal && content.type === "twain")
+        content.is_literal = true;
     }
 
-    return content
-  }
+    return content;
+  };
 
   cloth_content = async (content, options) => {
     let obj;
 
     if (!content) return content;
-    
+
     switch (content.type) {
       case "number":
         obj = new Num(content, this.account);
@@ -285,31 +300,31 @@ class Vm_utils {
       case "function":
         obj = new Func(content, this.account);
         break;
-      case 'folder':
-        obj = new Fold(content, this.account)
+      case "folder":
+        obj = new Fold(content, this.account);
         break;
-      case 'folder_response':
-        obj = new Res(content, this.account)
+      case "folder_response":
+        obj = new Res(content, this.account);
         break;
       case "class":
         obj = new Cls(content, this.account);
         break;
-      case 'error':
-        obj = new Err(content, this.account)
+      case "error":
+        obj = new Err(content, this.account);
         break;
       default:
-        obj = await this.cloth(content)
+        obj = await this.cloth(content);
         break;
     }
 
     return await obj.sync(options);
   };
 
-  hash = async(value, alg)=>{
-    if (typeof value !== 'string') value = JSON.stringify(value)
-    
-    return hash(value, alg)
-  }
+  hash = async (value, alg) => {
+    if (typeof value !== "string") value = JSON.stringify(value);
+
+    return hash(value, alg);
+  };
 }
 
 export default Vm_utils;

package/repos/fs.js

@@ -1,122 +0,0 @@
-import fs from "fs";
-import { copy_object } from "generalised-datastore/utils/functions.js";
-import Repository from "godprotocol/Objects/Repository.js";
-import { post_request } from "godprotocol/utils/services.js";
-
-class Fs extends Repository {
-  constructor(options = {}) {
-    super();
-
-    this._fs = fs;
-    this.__dirname = options.__dirname;
-    this.remote = options.remote;
-    this.name = options.name;
-
-    this.type = "fs";
-    this.cache = new Object();
-  }
-
-  parse_path = async (path) => {
-    path = path.split("/");
-    let addr = path.slice(0, -1).join("/");
-    if (!this._fs.existsSync(addr)) {
-      this._fs.mkdirSync(addr, { recursive: true });
-    }
-  };
-
-  call = async (payload) => {
-    let result;
-    switch (payload.op) {
-      case "write":
-        result = await this.write(payload.path, payload.data);
-        break;
-      case "read":
-        result = await this.read(payload.path);
-        break;
-    }
-    return result;
-  };
-
-  fetch = async (payload) => {
-    let res;
-    if (this.remote) {
-      res = await post_request({
-        options: {
-          ...this.remote,
-          path: "/oracle",
-        },
-        data: JSON.stringify({
-          method: "fs",
-          arg: { payload, name: this.name },
-        }),
-      });
-    } else {
-      res = await this.call(payload);
-    }
-
-    return res;
-  };
-
-  write_file = async (path, data) => {
-    path = this.path(path);
-    console.log(path, data);
-
-    await this.fetch({ path, data, op: "write" });
-  };
-
-  write = async (path, data) => {
-    await this.parse_path(path);
-    this._fs.writeFileSync(path, data);
-
-    this.cache[path] = data;
-  };
-
-  read = async (path) => {
-    let data;
-    try {
-      data = this.cache[path];
-      if (!data) {
-        await this.parse_path(path);
-        data = this._fs.readFileSync(path, { encoding: "utf-8" });
-      } else {
-        data = copy_object(data);
-      }
-    } catch (e) {
-      console.log(e.message);
-    }
-
-    return data;
-  };
-
-  read_file = async (path) => {
-    path = this.path(path);
-
-    let data = await this.fetch({ path, op: "read" });
-
-    return data;
-  };
-
-  path = (pth) => {
-    return `${this.__dirname}/${pth}`;
-  };
-
-  mkdir = async (path) => {
-    let done;
-    try {
-      this._fs.mkdirSync(this.path(path), { recursive: true });
-      done = true;
-    } catch (e) {
-      done = false;
-    }
-
-    return done;
-  };
-
-  exists = async (path) => {
-    path = this.path(path);
-
-    return !!this.cache[path] || this._fs.existsSync(path);
-  };
-}
-
-export default Fs;