godprotocol 1.2.52 → 1.2.53

package/Objects/Account.js

@@ -11,6 +11,7 @@ class Account extends Utils {
 
     this.name = name;
     this.options = options;
+    this.init = options?.init;
     this.manager = options.manager;
     this.vm = new Virtual_machine(this);
     this.compiler = new Compiler(this);
@@ -37,6 +38,8 @@ class Account extends Utils {
 
     let res = await chain.add_config(sequence, { ...options, _id });
 
+    await this.manager.emit("on_load", payload);
+
     return res;
   };
 
@@ -78,24 +81,7 @@ class Account extends Utils {
       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);
-        }
-        if (socket) {
-          // handle socket
-        }
+        await this.run_callback(res, { callback, socket });
       },
     });
 
@@ -103,6 +89,8 @@ class Account extends Utils {
       this.vm.envs[thread_id] = env;
     }
 
+    await this.manager.emit("on_run", payload);
+
     return { thread_id, callback };
   };
 
@@ -117,9 +105,13 @@ class Account extends Utils {
     let phy = `${this.physical_address}/${address}`;
 
     if (from === ".codes") {
-      let res = await this.manager.oracle.read(`.codes/${phy}.air`);
+      let res = await (
+        await this.manager.ds.folder(`.codes/${phy}.air`, {
+          account: this.physical_address,
+        })
+      ).readone(query?.query, query?.options);
       if (res) {
-        return { result: res };
+        return { result: res.sequence, _id: res._id };
       } else return { message: "Code not found" };
     } else if (from === "thread") {
       // is thread_id;
@@ -171,7 +163,7 @@ class Account extends Utils {
     return result;
   };
 
-  verify = async (password) => {
+  verify = async (password, init) => {
     let passes = await this.ds.folder(`${this.physical_address}/__passwords`, {
       account: this.physical_address,
     });
@@ -181,14 +173,18 @@ class Account extends Utils {
       passed = false;
 
     if (pass) {
-      passed = pass && pass.key === hash(password);
-    } else {
+      passed = pass.key === hash(password);
+    } else if (init) {
       passed = await passes.write({ key: hash(password) });
     }
 
-    this.servers =
-      passed &&
-      (await this.manager.oracle.update_servers(this.physical_address));
+    if (init)
+      this.servers =
+        passed &&
+        (await this.manager.oracle.update_servers(
+          this.physical_address,
+          this.servers
+        ));
 
     return passed;
   };
@@ -202,7 +198,7 @@ class Account extends Utils {
       res = true;
 
     if (pass) {
-      res = await this.verify(pass);
+      res = await this.verify(pass, this.is_init);
     }
 
     await register(this);

package/Objects/Clock.js

@@ -0,0 +1,9 @@
+import Events from "./Events.js";
+
+class Clock extends Events {
+  constructor() {
+    super();
+  }
+}
+
+export default Clock;

package/Objects/Events.js

@@ -0,0 +1,47 @@
+import { query_ } from "../callables/functions/query.js";
+
+class Events {
+  constructor() {
+    this.events_listeners = new Object();
+  }
+
+  add_listener = async (name, handler, filter) => {
+    let listeners = this.events_listeners[name];
+    if (!listeners) {
+      listeners = new Array();
+      this.events_listeners[name] = listeners;
+    }
+    if (
+      !listeners.find(
+        (li) =>
+          li.handler === handler &&
+          JSON.stringify(li.filter) === JSON.stringify(filter)
+      )
+    )
+      listeners.push({ handler, filter });
+  };
+
+  emit = async (name, payload, cb) => {
+    let listeners = this.events_listeners[name];
+    if (!listeners) return;
+
+    let total = 0;
+    for (let l = 0; l < listeners.length; l++) {
+      let { filter, handler } = listeners[l];
+
+      if (await query_(payload, filter, await this.ds.get_folder())) {
+        total++;
+        handler(payload)
+          .then((res) => {
+            total--;
+            cb && cb(res, { done: !total, event: { name, handler, filter } });
+          })
+          .catch((e) => {
+            console.log(e.message);
+          });
+      }
+    }
+  };
+}
+
+export default Events;

package/Objects/Manager.js

@@ -3,9 +3,12 @@ import Account from "./Account.js";
 import GDS from "generalised-datastore";
 import { hash } from "godprotocol/utils/hash.js";
 import { copy_object } from "generalised-datastore/utils/functions.js";
+import Clock from "./Clock.js";
 
-class Manager {
+class Manager extends Clock {
   constructor(name, options) {
+    super();
+
     this.name = name;
     this.options = options;
     this.trinity = options.trinity;
@@ -360,7 +363,7 @@ class Manager {
 
     this.ds = new GDS(this);
     await this.ds.sync();
-    let create_serv;
+
     if (this.options.server) {
       this.server = this.options.server;
       if (this.options.server.port)
@@ -383,18 +386,16 @@ class Manager {
               "Initiate manager account...",
               this.options.init_account.name
             );
-            // await this.add_account(this.options.init_account.name, {
-            //   password: this.options.init_account.password,
-            //   init: true,
-            // });
+            await this.add_account(this.options.init_account.name, {
+              password: this.options.init_account.password,
+              init: true,
+            });
 
             cb && cb();
           }
         }
       };
     }
-
-    return create_serv;
   };
 
   get_init = async () => {
@@ -421,14 +422,18 @@ class Manager {
     return acc;
   };
 
-  get_account = async (name) => {
+  get_account = async (name, password) => {
     let acc = this.accounts[name];
     if (!acc) {
       let servers = await this.oracle.read(`Accounts/${name}/.servers`);
       servers = servers ? JSON.parse(servers) : [];
       if (servers.length) {
-        acc = await this.add_account(name, { servers });
-      }
+        acc = await this.add_account(name, { servers, password });
+        if (!acc) return password ? "Invalid Password" : null;
+      } else return password ? "Account not found." : null;
+    } else if (password) {
+      let res = await acc.verify(password);
+      if (!res) return "Invalid Password";
     }
 
     return acc;

package/Objects/Oracle.js

@@ -1,5 +1,8 @@
 import { post_request } from "../utils/services.js";
-import { encrypt } from "@godprotocol/repositories/utils/cryptography.js";
+import {
+  encrypt,
+  decrypt,
+} from "@godprotocol/repositories/utils/cryptography.js";
 
 class Oracle_client {
   constructor(server, options = {}) {
@@ -7,11 +10,11 @@ class Oracle_client {
     this.manager_key = options.manager_key;
 
     this.repo_cache = new Object();
-    this.repos = [];
+    this.repos = new Array();
   }
 
   add_repo = async (repo) => {
-    let repo_ = await this.Repos.cloth_repo(repo.repo);
+    let repo_ = await this.cloth_repo(repo.repo);
     this.repos.push(repo_);
 
     await this.fetch({
@@ -60,7 +63,9 @@ class Oracle_client {
       content = response && response.content;
       if (content) {
         repo = response.repo;
-        repo = await this.cloth_repo(repo);
+        repo = await this.cloth_repo(
+          JSON.parse(decrypt(repo, this.manager_key))
+        );
         if (repo) this.repo_cache[path] = repo;
       }
     }
@@ -69,11 +74,18 @@ class Oracle_client {
 
   server_match = (s1, s2) => s1.hostname === s2.hostname && s1.port === s2.port;
 
-  update_servers = async (account) => {
+  get_servers = async (account) => {
     let addr = `${account}/.servers`;
 
     let servers = await this.read(addr);
     servers = servers ? JSON.parse(servers) : [];
+
+    return servers;
+  };
+
+  update_servers = async (account) => {
+    let servers = await this.get_servers(account);
+
     if (!servers.find((s) => this.server_match(s, this.client))) {
       servers.push(this.client);
       await this.write(addr, JSON.stringify(servers));
@@ -132,6 +144,7 @@ class Oracle_client {
       method: "authenticate",
       args: {
         client: this.client,
+        key: encrypt(this.manager_key, this.manager_key),
       },
     });
     if (!auth) return;

package/Objects/Utils.js

@@ -1,44 +1,82 @@
-class Utils{
-  on = async(event_name, filter, handler) => {
-    
-  }
+class Utils {
+  on = async (event_name, filter, handler) => {};
 
-  reload = async(payload)=>{
-    let {address} = payload;
+  reload = async (payload) => {
+    let { address } = payload;
 
-    let res = await this.manager.oracle.read(`${address}/air`, {address, prefix: '.codes', account: this.physical_address})
-    
-    await this.load({address: address.slice(this.physical_address.length+1), sequence: res, compiler: true, from_reload: true})
-  }
+    let res = await this.manager.oracle.read(`${address}/air`, {
+      address,
+      prefix: ".codes",
+      account: this.physical_address,
+    });
 
-  get_from_repo = async(address, options) =>{
-    address = `.storage/${this.physical_address}/${address}/__literal__`
-    let content = await this.manager.oracle.get_from_repos(address, {count: 1, args: options})
+    await this.load({
+      address: address.slice(this.physical_address.length + 1),
+      sequence: res,
+      compiler: true,
+      from_reload: true,
+    });
+  };
 
-    return content && JSON.parse(content)
-  }
+  run_callback = async (res, { callback, socket }) => {
+    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 net_fn = await this.vm.callable("net");
+        let url = await this.parse_net_url(callback);
+        if (url.path) return;
+        await net_fn.callable(
+          {
+            payload: {
+              header: { method: "POST" },
+              body: await this.vm.cloth(res),
+            },
+            account: url.account,
+            path: url.path,
+            server: url.server,
+          },
+          { vm: this.vm, chain: this.chain, no_then: true }
+        );
+      }
+    } else if (typeof callback === "function") {
+      await callback(res);
+    }
+    if (socket) {
+      // handle socket
+    }
+  };
 
-  set_to_repo =  async(address, content, options) =>{
-    address = `.storage/${this.physical_address}/${address}/__literal__`
-    let response = await this.manager.oracle.set_to_repos(address, JSON.stringify(content), {count: 1, args: options})
+  // acc+Arena://send_mail
+  parse_net_url = async (url) => {
+    url = url.split("://");
+    let protocol = url[0];
+    let payload = {};
 
-    return response
-  }
+    if (protocol.startsWith("acc+")) {
+      payload.account = protocol.split("+")[1];
+      payload.path = url[1];
+    } else if (protocol.startsWith("http")) {
+      let addr = url[1].split("/");
+      addr[1] = addr.slice(1).join("/");
+      addr[0] = addr.split(":");
 
-  read_file = async(address) =>{
-    let content = await this.manager.oracle.read(address, {account: this.physical_address})
+      payload.server = {
+        hostname: addr[0][0],
+        port: Number(addr[0][1]) || null,
+      };
+      payload.path = addr[1];
+    }
 
-    return content;
-  }
+    return payload;
+  };
 
-  write_file = async(address, content)=>{
-    let res = await this.manager.oracle.write(address, JSON.stringify(content), {account: this.physical_address})
-  }
-
-  read = async(address, query)=>{
-
-  }
+  read = async (address, query) => {};
 }
 
-
-export default Utils
+export default Utils;

package/callables/functions/net.js

@@ -1,20 +1,22 @@
 import { gen_random_int } from "generalised-datastore/utils/functions.js";
 import { post_request } from "../../utils/services.js";
 
-const net = async(args, {vm, chain, call_config, thread})=>{
-  let {server, path, account, payload} = args;
+const net = async (args, { vm, chain, no_then, call_config, thread }) => {
+  let { server, path, account, payload } = args;
 
-  thread.status = 'waiting'
-  path = await path.literal()
-  payload = await payload.literal()
-  let serv = server && [await server.literal()];
-  account = account ? await account.literal() : vm.account.name
-  if (!serv){
-    serv = await vm.account.manager.oracle.get_servers(`Accounts/${account}`)
+  thread.status = "waiting";
+  path = await path.literal();
+  if (no_then) {
+    payload.body = await payload.body.config;
+  } else payload = await payload.literal();
+  let serv = server && [no_then ? server : await server.literal()];
+  account = account ? await account.literal() : vm.account.name;
+  if (!serv && account) {
+    serv = await vm.account.manager.oracle.get_servers(`Accounts/${account}`);
   }
 
-  let s = gen_random_int(serv.length-1)
-  let servr = serv[s]
+  let s = gen_random_int(serv.length - 1);
+  let servr = serv[s];
 
   post_request({
     options: {
@@ -23,20 +25,23 @@ const net = async(args, {vm, chain, call_config, thread})=>{
       path: `/${path}`,
       method: payload.header.method.toUpperCase(),
       headers: {
-        ...payload.header
-      }
+        ...payload.header,
+      },
     },
-    data: payload.body && JSON.stringify(payload.body)
-  }).then(async res=>{
-    let adr = await vm.parse_aircode(res, {chain})
-    thread.results[thread.pointer-1] = adr;
-    thread.status = 'active'
-  }).catch(e=>{
-    console.log(e)
+    data: payload.body && JSON.stringify(payload.body),
   })
+    .then(async (res) => {
+      if (no_then) return;
 
-  return;
-}
+      let adr = await vm.parse_aircode(res, { chain });
+      thread.results[thread.pointer - 1] = adr;
+      thread.status = "active";
+    })
+    .catch((e) => {
+      console.log(e);
+    });
 
+  return;
+};
 
-export default net;
+export default net;

package/callables/functions/query.js

@@ -1,12 +1,17 @@
-const query = async(args, {vm, thread}) => {
-  let {object, filter} = args;
+const query_ = async (object, filter, folder) => {
+  let res = filter ? await folder.pass(object, filter) : true;
 
-  object = await object.literal()
-  filter = await filter.literal()
-
-  let res = await vm.account.chain.folder().pass(object, filter)
-  
   return res;
-}
+};
+
+const query = async (args, { vm, thread }) => {
+  let { object, filter } = args;
+
+  object = await object.literal();
+  filter = await filter.literal();
+
+  return await query_(object, filter, await vm.account.chain.folder());
+};
 
-export default query
+export default query;
+export { query_ };

package/package.json

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

package/utils/create_server.js

@@ -93,26 +93,13 @@ export const handle_routes = async (req, res, manager, app) => {
 
       switch (req.url) {
         case "/create_account": {
-          let acc = await manager.get_account(data.name);
-          if (acc) {
-            if (!(await acc.verify(data.password))) {
-              result = { message: "Incorrect password." };
-            } else {
-              const uid = generate_random_string(16, "alnum");
-              await set_account_uid(uid, data.name, manager);
-              result = { uid, message: "Account signed-in successfully." };
-            }
+          let acc = await manager.get_account(data.name, data.password);
+          if (acc?.physical_address) {
+            const uid = generate_random_string(16, "alnum");
+            await set_account_uid(uid, data.name, manager);
+            result = { uid, message: "Account signed-in successfully." };
           } else {
-            let new_acc = await manager.add_account(data.name, {
-              password: data.password,
-            });
-            if (new_acc) {
-              const uid = generate_random_string(16, "alnum");
-              await set_account_uid(uid, data.name, manager);
-              result = { uid, message: "Account created successfully." };
-            } else {
-              result = { message: "Account creation failed." };
-            }
+            result = { message: acc };
           }
           break;
         }