godprotocol 1.1.1 → 1.1.2

package/Objects/Oracle.js

@@ -1,110 +1,93 @@
 import fs from "fs";
 import GDS from "generalised-datastore";
-import { hash } from "../utils/hash";
 
-class Oracle {
-  constructor(mgr, meta) {
-    meta = meta || {};
-
-    this.compression = meta.compression;
+class Fs {
+  constructor(oracle) {
+    this.oracle = oracle;
     this.fs = fs;
-    this.mgr = mgr;
-    this.datapaths = new Object();
-    this.gds = new GDS(
-      meta.datastore || process.env.DATASTORE || "godprotocol"
-    ).sync({
-      manager: this.mgr,
-    });
+    this.base = __dirname;
   }
 
-  get_folder = (physical_address, options) => {
-    if (typeof options !== "object") {
-      options = { no_new: options ? false : true };
-    }
-    return this.gds.folder(this.hash(physical_address));
+  exists = async (path) => {
+    this.fs.existsSync(`${this.base}/${path}`);
   };
 
-  set = (path, { type, obj }) => {
-    this.datapaths[path] = {
-      obj,
-      type,
-    };
+  mkdir = async (path) => {
+    path = `${this.base}/${path}`;
+
+    !(await this.exists(path)) && this.fs.mkdirSync(path, { recursive: true });
   };
 
-  get = (path) => {
-    let obj = this.datapaths[path];
-
-    if (!obj) {
-      try {
-        obj = this.fs.readFileSync(`${this.mgr.root}/${path}`, {encoding:'utf-8'});
-        obj = JSON.parse(obj);
-        let type = obj && obj.payload && typeof obj.payload;
-        obj = obj && obj.payload;
-        type =
-          type === "object" ? (Array.isArray(obj) ? "array" : "twain") : type;
-
-        obj = { type, obj };
-        this.set(path, obj);
-      } catch (e) {
-        // console.log(e.message, 'Error thrown?')
-      }
-    }
+  read_file = async (path) => {
+    path = `${this.base}/${path}`;
+    try {
+      if (await this.exists(path)) return this.fs.readFileSync(path);
+      else return null;
+    } catch (e) {}
+  };
+
+  write_file = async (path, content) => {
+    if (typeof content !== "string") content = JSON.stringify(content);
 
-    return obj;
+    this.fs.writeFileSync(`${this.base}/${path}`, content, { recursive: true });
   };
+}
 
-  hash = (data, alg) => {
-    data = typeof data !== "string" ? JSON.stringify(data) : data;
-    return hash(data, alg);
+class Oracle {
+  constructor(manager) {
+    this.manager = manager;
+    this.repository = manager.repository;
+
+    this.fs = new Fs(this);
+    this.gds = new GDS(manager.name, { manager });
+  }
+
+  folder = async (physical_address, options) => {
+    return await this.gds.folder(physical_address, options);
   };
 
-  handle_compression = ({ addr, data, no_string }) => {
-    if (this.compression) {
-      let res = this.compression({ addr, data, no_string });
-      if (res) data = res.data;
-    }
-    if (!no_string && (typeof addr !== "string" || typeof data !== "string"))
-      return;
+  sync = async () => {
+    await this.gds.sync();
+  };
 
-    return data;
+  read = async (address, account) => {
+    let content = await this.repository.read_address(address);
+
+    return content;
   };
 
-  write = (address, payload) => { 
-    payload = JSON.stringify({ payload });
-    let data = this.handle_compression({
-      addr: address,
-      data: payload,
-    });
-    
-    this.fs.writeFileSync(`${this.mgr.root}/${address}`, data, {
-      encoding: "utf-8",
-    });
+  write = async (payload) => {
+    await payload.hash();
+
+    let address = await this.repository.write_file(
+      payload.path,
+      payload.content
+    );
+
+    return address;
   };
 
-  fetch = async (payload, callback) => {
-    let { physical_address, config, remote, query } = payload,
-      result;
-
-    let folder = this.get_folder(physical_address);
-
-    if (config) {
-      result = folder.config.stringify();
-      folder.add_remote(remote);
-    } else {
-      if (!folder.check_remote(query.operation)) {
-        result = {
-          error: true,
-          error_message: "Query operation cannot be performed remotely.",
-        };
-      } else {
-        let op = folder[query.operation];
+  add_server = async ({ path, ds, server }) => {
+    console.log(path, ds, "here", this.manager.server, server);
+    if (ds) {
+      if (this.gds.path === path) {
+        await this.gds.add_server(server);
 
-        result = await op(query.query, query.options);
-        folder.remote_stuff(remote, result);
+        return { listening: true };
+      } else return { not_found: true };
+    }
+    let folder = await this.gds.get_folder(path);
+    if (folder) {
+      await folder.add_server(server);
+      return { listening: true };
+    }
+    if (!folder) {
+      if (await this.fs.exists(path)) {
+        return { sleeping: true };
+      } else {
+        return { not_found: true };
       }
     }
-
-    callback(result);
   };
 }
 

package/Objects/Repository.js

@@ -0,0 +1,67 @@
+import { get_request, post_request } from "../utils/services";
+
+class Repository {
+  constructor(manager) {
+    this.manager = manager;
+
+    this.gds = this.manager.oracle.gds;
+  }
+
+  read_address = async (address) => {
+    let content = await get_request(`${address}`);
+
+    try {
+      content = JSON.parse(content);
+    } catch (err) {}
+
+    return content;
+  };
+
+  sync = async () => {
+    this.ds = await this.gds.sync();
+  };
+
+  create_or_update_file = async (path, content, message, sha) => {
+    post_request({
+      data: {
+        content: Buffer.from(content).toString("base64"),
+        message: message || `Updating file content - ${Date.now()}`,
+        sha,
+      },
+      options: this.repo_domain,
+      path: `/repos/${this.manager.username}/${this.manager.repo_name}/contents/${path}`,
+    });
+
+    console.log("File created/updated successfully:", response.data);
+  };
+
+  get_file_sha = async (path) => {
+    try {
+      let sha = await post_request({});
+      return sha;
+    } catch (error) {
+      if (error.response && error.response.status === 404) {
+        console.log("File does not exist; a new file will be created.");
+        return null; // File doesn't exist, so SHA is not needed
+      }
+      throw new Error(`Failed to get file SHA: ${error.message}`);
+    }
+  };
+
+  write_file = async (path, content, message = "") => {
+    try {
+      let sha = await this.get_file_sha(path);
+
+      console.log(`File ${path} created/updated successfully.`);
+    } catch (error) {
+      console.error("Error creating/updating file:", error);
+    }
+
+    // Usage
+    // createOrUpdateFile("username", "my-new-repo", "README.md", "Hello, world!", "Add README");
+
+    return `${this.repo_domain}/${owner}/${path}`;
+  };
+}
+
+export default Repository;

package/Objects/Trinity.js

@@ -0,0 +1,24 @@
+import Manager from "./Manager";
+
+class Trinity {
+  constructor() {
+    this.managers = new Object();
+  }
+
+  add_manager = async (name, options) => {
+    console.log(name, options);
+    let manager = new Manager(name, options);
+    let mgrs = this.managers[name];
+    if (!mgrs) {
+      mgrs = new Array();
+      this.managers[name] = mgrs;
+    }
+    await manager.sync();
+
+    mgrs.push(manager);
+
+    return manager;
+  };
+}
+
+export default Trinity;

package/Objects/Virtual_machine.js

@@ -1,224 +1,30 @@
-import Opcodes from "./Opcodes";
+import Callable from "./Callable";
 
-class Virtual_machine extends Opcodes {
-  constructor(context) {
+class Virtual_machine extends Callable {
+  constructor(account) {
     super();
 
-    this.account = context.account;
-    this.contexts = [context];
-    this.flags = {
-      neg: false,
-      equal: false,
-      zero: false,
-      void: false,
-    };
-
-    this.stacktrace = new Array()
-
-    this.error_manager = new Object()
-  }
-  
-  push_int = (name, payload)=>{
-    let stacks = this.error_manager[name]
-    if (!stacks){
-      stacks = new Array()
-      this.error_manager[name] = stacks;
-    }
-
-    stacks.push(payload)
+    this.account = account;
   }
 
-  quit = (payload)=>{
-    let instruction = this.track.sequence[this.track.pointer-1]
-
-    let { opcode } = this.split_instruction(instruction);
-    if(opcode==='ret'){
-      this.account.buff({ret:payload.op0}, this.track.pid)
-    }
-    this.track.pointer = this.track.sequence.length;
-  }
-
-  stderr = (err_object)=>{
-    console.log(err_object)
-    let{name, message} = err_object;
-
-    if (!name){
-      return this.quit(err_object)
-    }
-
-    let all = this.error_manager['*']
-    let stacks = this.error_manager[name]
-
-    if (!stacks){
-      if(all){
-        all = all.slice(-1)[0]
-        let object = this.read_chain(`${this.error_instance_address}/${name}_`)
-        stacks = [{object, metadata: all.metadata, catch_pointer: all.catch_pointer}]
-
-        if(!object)return this.quit({message: `Unknown Error instance - ${name}`})
-      }
-      
-      if (!stacks)
-      return this.quit(err_object)
-    }else if(all){
-      // Check precedence within all and stacks name, how?
-    }
-
-    let obj_payload, s;
-    for(s = this.stacktrace.length - 1; s >= 0; s--){
-      let trace = this.stacktrace[s]
-      let should_break;
+  sync = async () => {};
 
-      for (let t = stacks.length-1; t >= 0; t--){
-        obj_payload = stacks[t]
-        if(obj_payload.metadata.namespace === trace){
-          should_break = true
-          break;
-        }
-      }
-      if (should_break) break;
-    }
+  execute = async (instruction) => {
+    let { opcode, payload } = this.parse_instruction(instruction);
 
+    let callable = await this.callable(opcode);
 
-    if (!obj_payload){
-      return this.quit(err_object)
-    }
-
-    if(obj_payload.metadata.alias){
-      // Instantiate error message as an aircode string object.
-      let message_string = `${obj_payload.metadata.namespace}/${this.id_hash(
-        message
-      )}`;
-      this.air_object(message, {
-        location: message_string,
-        callback: () => {
-          this.exec({
-            executable: obj_payload.object.set_message,
-            location: obj_payload.metadata.alias,
-            metadata: {
-              callback: () => {
-                this.slice_trace(s+1)
-
-                this.track = this.account.manager.set_track({account: this.account.name, physical_address: obj_payload.metadata.namespace, pointer: obj_payload.catch_pointer}, true)
-              },
-            },
-            arguments: {
-              argv: [
-                {
-                  address: message_string,
-                  position: 0,
-                },
-              ],
-              argc: 1,
-            },
-          });
-        },
+    if (!callable) {
+      return await this.stderr({
+        name: "runtime_error",
+        message: `opcode:${opcode} is not set.`,
       });
-     
-    }else {
-      this.slice_trace(s-3)
-      
-      this.track = this.account.manager.set_track({account: this.account.name, physical_address: obj_payload.metadata.namespace, pointer: obj_payload.catch_pointer}, true)
-
     }
-  }
+    let call = callable.callable;
+    let args = await this.parse_arguments(payload, callable.config);
 
-  execute = (instruction, track) => {
-    this.track = track;
-
-    if (!instruction) return;
-
-    let { opcode, args } = this.split_instruction(instruction);
-
-    let context = this.get_context(-1);
-
-    if (!context || opcode === 'pass') return;
-
-    context.add_tx(instruction);
-
-    // console.log(`(${track.pointer}/${track.sequence.length})`)
-    // console.log(`(${track.pointer}/${track.sequence.length-1})>> ${instruction}`)
-    // this.account.log_output(`>> ${instruction}`);
-
-    let chain;
-
-    args = this.parse_arg(args, opcode);
-
-    switch (opcode) {
-      case "chain":
-        
-        chain = this.handle_chain(args, context)
-
-        if(!chain)return this.stderr(`Chain error - ${args}`)
-       
-        this.push_context(chain);
-
-        let dim = context.folder.config.dimensions;
-        if (!dim) {
-          dim = [];
-          context.folder.config.dimensions = dim;
-        }
-        !dim.find((d) => d === args) && dim.push(args);
-
-        chain.append_buffer();
-
-        process.exit()
-        break;
-      case "link":
-        chain = this.handle_chain(args, context)
-
-        if (!chain) {
-         return this.stderr(`LINKing Failed. - ${args}`)
-        }
-
-        chain.append_buffer();
-
-        this.push_context(chain);
-
-        break;
-      case "pop":
-        let blk;
-        if (context.txs.length > 1) {
-          blk = context.mine(this);
-        } else {
-          if (this.account.initiated&& this.account.is_datatype(context)){
-            blk= context.mine(this)
-          }else {
-            blk = context.get_latest_block();
-            if(!blk || context.datapath){
-              if(context.datapath){
-                blk = context.fabricate_datapath_block()
-              }else blk = this.get_voided_block()
-            }
-            
-            if (blk){
-              if (blk.chain.physical_address!== `${this.account.physical_address}/Datatypes/Void`) this.flags.void = false
-
-              this.get_context(-2).connections.push(blk);
-            }
-
-            context.get_buffer()
-            context.txs = [];
-          }
-         
-        }
-
-        blk && this.account.buff(blk, this.track.pid);
-
-        this.pop_context();
-        break;
-      case "cursor":
-        context.set_cursor(args);
-        break;
-      case "write":
-        context.account.write(args, context);
-        break;
-      case "pass":
-        break;
-      default:
-        this.prepare_operation(opcode, context);
-        break;
-    }
+    let result = await call(args);
+    return result;
   };
 }
 

package/callables/functions/assign.js

@@ -0,0 +1,6 @@
+const assign = async (args, vm, options) => {
+  console.log(args);
+  process.exit();
+};
+
+export default assign;

package/callables/functions/display.js

@@ -0,0 +1,3 @@
+const display = async (args) => {};
+
+export default display;

package/callables/register.js

@@ -0,0 +1,22 @@
+import assign from "./functions/assign";
+import display from "./functions/display";
+
+const register = async (account) => {
+  let set = account.vm.set;
+
+  set("assign", {
+    callable: assign,
+    config: {
+      parameters: [{ name: "assignment", position: 0 }],
+    },
+  });
+
+  set("display", {
+    callable: display,
+    config: {
+      parameters: [{ name: "data", position: 0, spread: true }],
+    },
+  });
+};
+
+export default register;

package/package.json

@@ -1,60 +1,41 @@
 {
   "name": "godprotocol",
-  "version": "1.1.1",
-  "description": "A data mediator.",
+  "version": "1.1.2",
+  "description": "A distributed computing environment",
   "main": "Index.js",
-  "types": "types/index.d.ts",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
-    "start": "nodemon -r esm Index.js",
-    "prepack": "npmignore"
-  },
-  "author": "Savvy",
-  "license": "ISC",
-  "devDependencies": {
-    "@babel/cli": "latest",
-    "@babel/core": "^7.19.1",
-    "apidoc": "^0.54.0",
-    "babel-preset-env": "^1.7.0",
-    "esm": "^3.2.25",
-    "nodemon": "^3.1.0",
-    "npmignore": "^0.3.1"
+    "start": "nodemon -r esm Index.js"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/godprotocol4/godprotocol.git"
-  },
-  "bugs": {
-    "url": "https://github.com/godprotocol4/godprotocol/issues"
+    "url": "git+https://github.com/immanuel-savvy/GodProtocol.git"
   },
-  "homepage": "https://github.com/godprotocol4/godprotocol#readme",
   "keywords": [
-    "web 4.0",
-    "framework",
-    "intelligence",
-    "AR / VR",
-    "modeling",
-    "load sequence",
-    "blockchain",
-    "instruction",
-    "decentralisation",
-    "distribution",
-    "flow",
-    "godprotocol"
+    "decentralise",
+    "distribute",
+    "web4",
+    "ai",
+    "ar",
+    "vr",
+    "virtual-machine"
   ],
+  "author": "Savvy",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/immanuel-savvy/GodProtocol/issues"
+  },
+  "homepage": "https://github.com/immanuel-savvy/GodProtocol#readme",
   "dependencies": {
+    "@octokit/rest": "^21.0.2",
     "crypto": "^1.0.1",
-    "elliptic": "^6.5.5",
+    "elliptic": "^6.6.0",
     "fs": "^0.0.1-security",
-    "generalised-datastore": "^2.0.112"
+    "generalised-datastore": "^2.0.13",
+    "js-base64": "^3.7.7"
   },
-  "publishConfig": {
-    "ignore": [
-      "Accounts/",
-      ".github/",
-      "build/",
-      ".babelrc",
-      "node_modules/"
-    ]
+  "devDependencies": {
+    "esm": "^3.2.25",
+    "nodemon": "^3.1.7"
   }
 }