godprotocol 1.1.32 → 1.2.0

package/Objects/Account.js

@@ -1,135 +1,185 @@
-import Utils from "./Utils";
-import register from "../callables/register";
-import Chain from "./Chain";
-import Virtual_machine from "./Virtual_machine";
+import Utils from "./Utils.js";
+import Compiler from "aircode4";
+import Chain from "./Chain.js";
+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)
+  }
+
+  load = async(payload, options)=>{
+    let {address, sequence, compiler, from_reload, _id} = payload
 
-class Account extends Utils {
-  constructor(name, options) {
-    super();
+    let phy = `${this.physical_address}/${address}`
+    let chain = await this.chain.chain(phy)
 
-    this.name = name;
+    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})
 
-    this.manager = options.manager;
-    this.parent = options.parent || this;
-    this.repository = this.manager.repository;
-    this.account = this;
+    return res;
+  }
 
-    this.physical_address = `Accounts/${name}`;
-    this.buffs = new Array();
+  run = async(payload, socket)=>{
+    let {address, _id, env, config, thread, callback}= payload;
 
-    this.chain = new Chain(this.physical_address, this.parent);
-    this.path = this.chain.path;
+    if(!config){
+      let phy = `${this.physical_address}/${address}`
+      let chain = await this.chain.chain(phy)
 
-    console.log(`Account Created: ${this.name}`);
-  }
+      let folder = await chain.folder('.configs')
+      config = await folder.readone(_id? {_id}: null)
 
-  load = async (payload) => {
-    let { sequence: codes, account, physical_address, options } = payload;
+      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]
 
-    console.log(payload);
-    if (account && account !== this.name) {
-      account = await this.manager.get_account(account);
-      if (account) {
-        return await account.load(payload);
-      } else return { error: true, message: "Account not found!" };
-    }
+          config = code;
 
-    if (typeof codes === "string") {
-      codes = await this.compiler.to_sequence(codes, physical_address);
-      if (options) {
-        codes = codes[0].body[options.line];
+          await this.load({address, sequence: config, _id})
+        }
       }
     }
-    if (Array.isArray(codes)) {
-      codes = codes[0];
+    
+    if (!config){
+      return {message: 'Code not found!'}
     }
 
-    physical_address = `${this.physical_address}/${physical_address}`;
+    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)
+      }
+      if (socket){
+        // handle socket
+      }
+    }})
 
-    let chain = await this.chain.chain(physical_address);
+    if (env){
+      this.vm.envs[thread_id] = env
+    }
 
-    let res = { value: await chain.add_config(codes), type: "address" };
+    return {thread_id, callback}
+  }
+  
+  parse = async (payload)=>{
+    let {address, query, retrieve, from} = payload
 
-    console.log(res, codes, chain.physical_address);
-    return res;
-  };
-
-  run = async (payload) => {
-    let { physical_address, account, options } = payload;
-
-    let acc = (await this.manager.get_account(account)) || this;
-    let chain = await acc.chain.chain(
-      `${acc.physical_address}/${physical_address}`
-    );
-
-    console.log(chain.physical_address);
-    let config = await chain.read({ config: true });
-
-    if (options.env) {
-      let res = await this.load({
-        sequence: `env = ${JSON.stringify(options.env)}`,
-        physical_address: `${physical_address}`,
-        options: { line: 0 },
-      });
-      await this.vm.execute(res.value, { chain });
+    if (!address){
+      return {
+        message: 'Invalid payload.'
+      }
     }
+    let phy = `${this.physical_address}/${address}`
 
-    let res = await this.vm.execute(config, { chain, main: true });
-    if (options && options.literal) {
-      if (res.type === "address") {
-        let conf = await this.vm.resolve_address(res.value);
-        res = {
-          address: res,
-          literal: await (await this.vm.cloth_content(conf)).literal(),
-        };
+    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 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)
+      }
+    } 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)
       }
     }
 
+    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)
+
+    let passes = await this.ds.folder(`${this.physical_address}/__passwords`, {account: this.physical_address})
+
+    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)})
+
+    return 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)
+    }
+
+    await register(this)
+
     return res;
-  };
-
-  parse = async (payload) => {
-    let { account, physical_address, depth, history, query } = payload;
-
-    let acc = (await this.manager.get_account(account)) || this;
-    let chain = await acc.chain.chain(
-      `${acc.physical_address}/${physical_address}`
-    );
-
-    let config = await chain.read({ query, depth, history });
-    return config;
-  };
-
-  add_account = async (name, options) => {
-    let acc = new Account(name, {
-      ...options,
-      manager: this.manager,
-      parent: this,
-    });
-    await acc.sync();
-
-    return acc;
-  };
-
-  sync = async () => {
-    this.servers = new Array();
-    this.vm = new Virtual_machine(this);
-    this.compiler = new this.manager.compiler(this);
-
-    await this.chain.sync();
-    await this.vm.sync();
-
-    await register(this);
-  };
-
-  stringify = () => {
-    return {
-      physical_address: this.physical_address,
-      path: this.path,
-      name: this.name,
-      private: this.private,
-    };
-  };
+  }
 }
 
 export default Account;

package/Objects/Blockweb.js

@@ -1,3 +1,5 @@
+import Chain from "./Chain.js";
+
 class Blockweb{
   constructor(mgr){
     this.mgr = mgr;
@@ -6,17 +8,10 @@ class Blockweb{
   }
 
   set = async(physical_address, parent)=>{
-    let load = this.chains[physical_address]
-    if (!load){
-      load = {parents: new Object(), chains: new Array()}
-      this.chains[physical_address] = load
-    }
-
-    load.parents[parent.physical_address] = parent;
-    let child = await parent.birth(physical_address)
-    load.chains.push(child)
-
-    return child;
+    let folder = new Chain(physical_address, parent)
+    await folder.sync()
+    
+    return folder;
   }
 }