godprotocol 1.2.26 → 1.2.27

package/Objects/Account.js

@@ -5,185 +5,215 @@ import Virtual_machine from "./Virtual_machine.js";
 import register from "godprotocol/callables/register.js";
 import { hash } from "godprotocol/utils/hash.js";
 
-class Account extends Utils{
-  constructor(name, options){
-    super()
-
-    this.name = name
-    this.options = options
-    this.manager = options.manager
-    this.vm = new Virtual_machine(this)
-    this.compiler = new Compiler(this)
+class Account extends Utils {
+  constructor(name, options) {
+    super();
+
+    this.name = name;
+    this.options = options;
+    this.manager = options.manager;
+    this.vm = new Virtual_machine(this);
+    this.compiler = new Compiler(this);
   }
 
-  load = async(payload, options)=>{
-    let {address, sequence, compiler, from_reload, _id} = payload
+  load = async (payload, options) => {
+    let { address, sequence, compiler, from_reload, _id } = payload;
 
-    let phy = `${this.physical_address}/${address}`
-    let chain = await this.chain.chain(phy)
+    let phy = `${this.physical_address}/${address}`;
+    let chain = await this.chain.chain(phy);
 
-    if (compiler){
-      !from_reload && await this.manager.oracle.write(`${phy}.air`, sequence, {account: this.physical_address, prefix: '.codes', address: phy})
-      
-      sequence = await this.compiler.to_sequence(sequence, address)
-      sequence = sequence[0]
+    if (compiler) {
+      !from_reload &&
+        (await this.manager.oracle.write(`${phy}.air`, sequence, {
+          account: this.physical_address,
+          prefix: ".codes",
+          address: phy,
+        }));
+
+      sequence = await this.compiler.to_sequence(sequence, address);
+      sequence = sequence[0];
     }
-    
-    let res = await chain.add_config(sequence, {...options, _id})
+
+    let res = await chain.add_config(sequence, { ...options, _id });
 
     return res;
-  }
+  };
 
-  run = async(payload, socket)=>{
-    let {address, _id, env, config, thread, callback}= payload;
+  run = async (payload, socket) => {
+    let { address, _id, env, config, thread, callback } = payload;
 
-    if(!config){
-      let phy = `${this.physical_address}/${address}`
-      let chain = await this.chain.chain(phy)
+    if (!config) {
+      let phy = `${this.physical_address}/${address}`;
+      let chain = await this.chain.chain(phy);
 
-      let folder = await chain.folder('.configs')
-      config = await folder.readone(_id? {_id}: null)
+      let folder = await chain.folder(".configs");
+      config = await folder.readone(_id ? { _id } : null);
 
-      if (!config){
-        let code = await this.manager.oracle.read(`${phy}.air`, {account: this.physical_address, prefix: '.codes', address: phy})
-        if (code){
-          code = await this.compiler.to_sequence(code, address)
-          code = code[0]
+      if (!config) {
+        let code = await this.manager.oracle.read(`${phy}.air`, {
+          account: this.physical_address,
+          prefix: ".codes",
+          address: phy,
+        });
+        if (code) {
+          code = await this.compiler.to_sequence(code, address);
+          code = code[0];
 
           config = code;
 
-          await this.load({address, sequence: config, _id})
+          await this.load({ address, sequence: config, _id });
         }
       }
     }
-    
-    if (!config){
-      return {message: 'Code not found!'}
+
+    if (!config) {
+      return { message: "Code not found!" };
     }
 
-    let result = await this.vm.nodelist(config)
-
-    let thread_id = await this.manager.load(result, this, {spawn: thread && thread._id, pointer: thread && thread.pointer, callback: async res=>{
-      if (typeof callback === 'string'){
-        if (callback === 'store' && !Array.isArray(res)){
-          let store_fn = await this.vm.callable('store');
-          await store_fn.callable({object: await this.vm.cloth(res)}, {vm: this.vm, chain: this.chain})
-          callback = res.value
-        }else {
-          let folder = await this.ds.folder(callback)
-          await folder.write(res, {replace: true})
+    let result = await this.vm.nodelist(config);
+
+    let thread_id = await this.manager.load(result, this, {
+      spawn: thread && thread._id,
+      pointer: thread && thread.pointer,
+      callback: async (res) => {
+        if (typeof callback === "string") {
+          if (callback === "store" && !Array.isArray(res)) {
+            let store_fn = await this.vm.callable("store");
+            await store_fn.callable(
+              { object: await this.vm.cloth(res) },
+              { vm: this.vm, chain: this.chain }
+            );
+            callback = res.value;
+          } else {
+            let folder = await this.ds.folder(callback);
+            await folder.write(res, { replace: true });
+          }
+        } else if (typeof callback === "function") {
+          await callback(res);
         }
-      }else if (typeof callback === 'function'){
-        await callback(res)
-      }
-      if (socket){
-        // handle socket
-      }
-    }})
+        if (socket) {
+          // handle socket
+        }
+      },
+    });
 
-    if (env){
-      this.vm.envs[thread_id] = env
+    if (env) {
+      this.vm.envs[thread_id] = env;
     }
 
-    return {thread_id, callback}
-  }
-  
-  parse = async (payload)=>{
-    let {address, query, retrieve, from} = payload
+    return { thread_id, callback };
+  };
 
-    if (!address){
-      return {
-        message: 'Invalid payload.'
-      }
-    }
-    let phy = `${this.physical_address}/${address}`
+  parse = async (payload) => {
+    let { address, query, retrieve, from } = payload;
 
-    if (from === '.codes'){
-      let res = await this.manager.oracle.read(`${phy}.air`, {account: this.physical_address, address: phy, prefix: from})
-      if (res){
-        return {result: res}
-      }else return {message: 'Code not found'}
+    if (!address) {
+      return {
+        message: "Invalid payload.",
+      };
     }
-    else if (from === 'thread'){
+    let phy = `${this.physical_address}/${address}`;
+
+    if (from === ".codes") {
+      let res = await this.manager.oracle.read(`${phy}.air`, {
+        account: this.physical_address,
+        address: phy,
+        prefix: from,
+      });
+      if (res) {
+        return { result: res };
+      } else return { message: "Code not found" };
+    } else if (from === "thread") {
       // is thread_id;
-      let thread_info = this.manager.accounts_pairs[this.name]
-      let thread = thread_info.threads[address]
-
-      return thread ? {
-        _id: thread._id,
-        status: thread.status,
-        spawn: thread.spawn,
-        callback: thread.callback,
-        pointer: thread.pointer,
-        total: thread.bullets.length
-      } : {}
+      let thread_info = this.manager.accounts_pairs[this.name];
+      let thread = thread_info.threads[address];
+
+      return thread
+        ? {
+            _id: thread._id,
+            status: thread.status,
+            spawn: thread.spawn,
+            callback: thread.callback,
+            pointer: thread.pointer,
+            total: thread.bullets.length,
+          }
+        : {};
     }
 
-    let folder = await this.ds.folder(phy, from === 'ram' ? null : {account: this.physical_address})
-    
-    let result = await folder.readone(query.query, {...query.options})
+    let folder = await this.ds.folder(
+      phy,
+      from === "ram" ? null : { account: this.physical_address }
+    );
+
+    let result = await folder.readone(query.query, { ...query.options });
     if (!result) return result;
-    
-    if (from !== 'ram'){
-      if (this.vm.datatypes.includes(result.type)){
-        let obj = await this.vm.retrieve(result, true)
-        if (retrieve){
-          result = await obj.to_address()
-        } else result.literal = await (obj).literal()
-      }else if (retrieve){
-        result = await this.vm.retrieve(result)
+
+    if (from !== "ram") {
+      if (this.vm.datatypes.includes(result.type)) {
+        let obj = await this.vm.retrieve(result, true);
+        if (retrieve) {
+          result = await obj.to_address();
+        } else result.literal = await obj.literal();
+      } else if (retrieve) {
+        result = await this.vm.retrieve(result);
       }
     } else {
-      if (this.vm.datatypes.includes(result.type)){
-        if (retrieve){
-          result = await (await this.vm.cloth_content(result)).to_address()
-        }else result.literal = await (await this.vm.cloth_content(result)).literal()
-      }else if (retrieve){
-        result = await this.vm.cloth_content(result)
+      if (this.vm.datatypes.includes(result.type)) {
+        if (retrieve) {
+          result = await (await this.vm.cloth_content(result)).to_address();
+        } else
+          result.literal = await (
+            await this.vm.cloth_content(result)
+          ).literal();
+      } else if (retrieve) {
+        result = await this.vm.cloth_content(result);
       }
     }
 
-    return result
-  }
+    return result;
+  };
 
-  verify = async(password)=>{
-    let servers = await this.manager.oracle.get_servers(this.physical_address)
-    
-    if(!servers.length) servers = await this.manager.oracle.update_servers(this.physical_address)
+  verify = async (password) => {
+    let passes = await this.ds.folder(`${this.physical_address}/__passwords`, {
+      account: this.physical_address,
+    });
 
-    let passes = await this.ds.folder(`${this.physical_address}/__passwords`, {account: this.physical_address})
+    let pass = await passes.readone(),
+      passed = false;
 
-    let pass = await passes.readone()
-    
-    if (pass){
-      let passed = pass && pass.key === hash(password)
-      
-      passed && await this.manager.oracle.update_servers(this.physical_address)
-      return passed
-    }else await passes.write({key: hash(password)})
+    if (pass) {
+      passed = pass && pass.key === hash(password);
+    } else {
+      passed = await passes.write({ key: hash(password) });
+    }
 
-    return true;
-  }
-  
-  sync = async()=>{
-    this.physical_address = `${"Accounts"}/${this.name}`
-    this.chain = new Chain(`${this.physical_address}`, this)
-    this.ds = this.manager.ds
+    this.servers =
+      passed &&
+      (await this.manager.oracle.update_servers(this.physical_address));
+
+    return passed;
+  };
 
-    let pass = this.options.password, res = true
+  sync = async () => {
+    this.physical_address = `${"Accounts"}/${this.name}`;
+    this.chain = new Chain(`${this.physical_address}`, this);
+    this.ds = this.manager.ds;
+
+    let pass = this.options.password,
+      res = true;
 
     if (pass) {
-      res = await this.verify(pass)
+      res = await this.verify(pass);
     }
 
-    await register(this)
+    await register(this);
 
-    if (res){
-      console.log(`Account:${this.name} initiation successful!`)
-    } else console.log(`Account:${this.name} initiation failed!`)
+    if (res) {
+      console.log(`Account:${this.name} initiation successful!`);
+    } else console.log(`Account:${this.name} initiation failed!`);
 
     return res;
-  }
+  };
 }
 
 export default Account;

package/Objects/Manager.js

@@ -372,22 +372,20 @@ class Manager {
         app: this.options.app,
       });
 
-      this.handler = (req, res, cb) => {
+      this.handler = async (req, res, cb) => {
         handle(req, res);
 
         if (this.options.oracle && !this.served) {
           this.served = true;
           this.oracle = this.options.oracle;
-          this.oracle.sync(this).then(async () => {
-            if (this.options.init_account) {
-              await this.add_account(this.options.init_account.name, {
-                password: this.options.init_account.password,
-                init: true,
-              });
-
-              cb && cb();
-            }
-          });
+          if (this.options.init_account) {
+            await this.add_account(this.options.init_account.name, {
+              password: this.options.init_account.password,
+              init: true,
+            });
+
+            cb && cb();
+          }
         }
       };
     }

package/Objects/Oracle.js

@@ -3,15 +3,14 @@ import { post_request } from "../utils/services.js";
 class Oracle_client {
   constructor(server) {
     this.server = server;
+
+    this.repo_cache = new Object();
   }
 
-  add_repo = async (repo, filter) => {
+  add_repo = async (repo) => {
     await this.fetch({
       method: "add_repo",
-      args: {
-        repo,
-        filter,
-      },
+      args: repo,
     });
   };
 
@@ -23,7 +22,9 @@ class Oracle_client {
   };
 
   read = async (path) => {
-    let repo = this.repo_cache[path];
+    let repo = this.repo_cache[path],
+      content;
+
     if (repo) {
       content = await repo.read(path);
     }
@@ -42,21 +43,40 @@ class Oracle_client {
     return content;
   };
 
+  server_match = (s1, s2) => s1.hostname === s2.hostname && s1.port === s2.port;
+
+  update_servers = async (account) => {
+    let addr = `${account}/.servers`;
+
+    let servers = await this.read(addr);
+    servers = servers ? JSON.parse(servers) : [];
+    if (!servers.find((s) => this.server_match(s, this.client))) {
+      servers.push(this.client);
+      await this.write(addr, JSON.stringify(servers));
+    }
+    return servers;
+  };
+
   fetch = async (payload) => {
+    let headers;
     if (payload.method !== "authenticate" && !this.auth_token) {
       await this.sync(this.client);
+    } else if (payload.method !== "authenticate") {
+      headers = {
+        authorisation: this.auth_token,
+      };
     }
+
     try {
       let resp = await post_request({
         options: {
           ...this.server,
           path: `/oracle/${payload.method}`,
-          headers: {
-            authorisation: this.auth_token,
-          },
+          headers,
         },
         data: JSON.stringify(payload.args),
       });
+
       return resp || null;
     } catch (e) {
       console.warn("fetch error:", e.message || e);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "godprotocol",
-  "version": "1.2.26",
+  "version": "1.2.27",
   "description": "A distributed computing environment for Web 4.0 — integrating AI, decentralisation, and virtual computation.",
   "main": "Index.js",
   "type": "module",