godprotocol 1.1.1 → 1.1.2

package/Datatypes/arr.js

@@ -1,30 +1,11 @@
-import Storage from 'godprotocol/Datatypes/objects/storage'
+import Storage from "./functions/storage";
 
-const arr = (args, vm, options)=>{
-  let {value} = args;
+class Arr extends Storage {
+  constructor(value) {
+    super();
 
- Storage.cold_store(value, vm, options)
-}
-
-
-class Arr extends Storage{
-  constructor(value, vm){
-    super()
-    
-    this.value = value
-    this.vm = vm
-  }
-
-  literal = ()=>{
-    return this.value.map(val=>{
-      return this.vm.account.cloth_object(this.vm.read_chain(val)).literal()
-    })
-  }
-
-  store = (options)=>{
-    Storage.cold_store(this.value, this.vm, options)
+    this.value = value;
   }
 }
 
-export default Arr
-export {arr}
+export default Arr;

package/Datatypes/bool.js

@@ -1,25 +1,11 @@
-import Storage from './objects/storage'
-
-const bool = (args, vm, options)=>{
-  let {value} = args;
-
-  if (value.static_address) value = vm.literal(value)
-  
-  let obj = new Bool(!!value, vm)
-  obj.store()
-
-  vm.air_object(obj, options)
-}
+import Storage from "./functions/storage";
 
 class Bool extends Storage {
-  constructor(value, vm){
-    super()
+  constructor(value) {
+    super();
 
     this.value = value;
-    this.vm = vm
   }
-
 }
 
-export default Bool
-export {bool}
+export default Bool;

package/Datatypes/callable.js

@@ -0,0 +1,11 @@
+import Storage from "./functions/storage";
+
+class Callable extends Storage {
+  constructor(value) {
+    super();
+
+    this.value = value;
+  }
+}
+
+export default Callable;

package/Datatypes/functions/storage.js

@@ -0,0 +1,5 @@
+class Storage {
+  constructor() {}
+}
+
+export default Storage;

package/Datatypes/num.js

@@ -1,22 +1,11 @@
-import Storage from 'godprotocol/Datatypes/objects/storage'
-
-const num = (args, vm, options)=>{
-  let {value} = args;
-  
-  let obj = new Num(value, vm)
-  obj.store()
-
-  vm.air_object(obj, options)
-}
+import Storage from "./functions/storage";
 
 class Num extends Storage {
-  constructor(value, vm){
-    super()
+  constructor(value) {
+    super();
 
     this.value = value;
-    this.vm = vm
   }
 }
 
-export default Num
-export {num}
+export default Num;

package/Datatypes/str.js

@@ -1,23 +1,11 @@
-import Storage from 'godprotocol/Datatypes/objects/storage'
-
-const str = (args, vm, options)=>{
-  let {value} = args;
-
-  
-  let obj = new Str(value, vm)
-  obj.store()
-
-  vm.air_object(obj, options)
-}
+import Storage from "./functions/storage";
 
 class Str extends Storage {
-  constructor(value, vm){
-    super()
+  constructor(value) {
+    super();
 
     this.value = value;
-    this.vm = vm
   }
 }
 
-export default Str
-export {str}
+export default Str;

package/Datatypes/twa.js

@@ -1,30 +1,11 @@
-import Storage from './objects/storage'
-
-const twa = (args, vm, options)=>{
-  let {value} = args;
-
-  Storage.cold_store(value, vm, options)
-}
+import Storage from "./functions/storage";
 
 class Twa extends Storage {
-  constructor(value, vm){
-    super()
+  constructor(value) {
+    super();
 
     this.value = value;
-    this.actual_static = value
-    this.vm = vm
-  }
-
-  literal = ()=>{
-    let lit = {}
-    for (let v in this.value){
-      let [prop, val] = this.value[v]
-      
-      lit[this.vm.account.cloth_object(this.vm.read_chain(prop)).literal()] = this.vm.account.cloth_object(this.vm.read_chain(val)).literal()
-    }
-    return lit
   }
 }
 
-export default Twa
-export {twa}
+export default Twa;

package/Datatypes/voi.js

@@ -1,23 +1,11 @@
-import Storage from 'godprotocol/Datatypes/objects/storage'
-
-const voi = (args, vm, options)=>{
-  let {value} = args;
-
-  
-  let obj = new Voi(value, vm)
-  obj.store()
-
-  vm.air_object(obj, options)
-}
+import Storage from "./functions/storage";
 
 class Voi extends Storage {
-  constructor(value, vm){
-    super()
+  constructor(value) {
+    super();
 
     this.value = value;
-    this.vm = vm
   }
 }
 
-export default Voi
-export {voi}
+export default Voi;

package/Index.js

@@ -1,4 +1,38 @@
-import Trinity from "./Trinity";
+import Trinity from "./Objects/Trinity";
 
+let trinity = new Trinity();
 
-export default new Trinity();
+const starter = async () => {
+  let manager = await trinity.add_manager("Arena_classic", {
+    server: {
+      port: 1408,
+      hostname: "127.0.0.1",
+      repo: true,
+    },
+    repositories: [
+      // {server}
+    ],
+  });
+
+  // let manager2 = await trinity.add_manager("Arena_classic", {
+  //   server: {
+  //     port: 1409,
+  //     hostname: "127.0.0.1",
+  //     repo: true,
+  //   },
+  //   sync_server: {
+  //     port: 1408,
+  //     hostname: "127.0.0.1",
+  //   },
+  //   repositories: [
+  //     // {server}
+  //   ],
+  // });
+
+  let account = await manager.add_account("lola");
+  // let account2 = await manager2.add_account("lola");
+};
+
+starter();
+
+export default trinity;

package/Objects/Account.js

@@ -1,290 +1,62 @@
-import Loader_sequence from "../Loader_sequence/main";
-import validate_signature from "../utils/privacy";
-import { post_request } from "../utils/services";
-import Filesystem from "./Filesystem";
+import register from "../callables/register";
+import Chain from "./Chain";
 import Virtual_machine from "./Virtual_machine";
 
-class Account extends Filesystem {
-  constructor(name, meta = {}) {
-    super();
-
-    meta = meta || {};
-
+class Account {
+  constructor(name, options) {
     this.name = name;
-    this.private = meta.private;
-    this.manager = meta.manager;
-    this.account = this;
-    this.stdin = new Array();
-    this.stdout = new Array();
-
-    this.log_output = this.manager.clock.logger.store_log
-
-    if (!this.manager) throw new Error("Manager instance missing.");
-
-    this.name_hash();
-    this.physical_address = `${this.base_address}/${this.name}`;
-    this.set_paths(this);
 
-    this.loader = new Loader_sequence(this);
+    this.manager = options.manager;
+    this.repository = this.manager.repository;
 
-    this.chain = this.account_chain(this);
-    this.vm = new Virtual_machine(this.chain);
+    this.physical_address = `Accounts/${name}`;
 
-    this.mine_buffer = {};
-    this.privileges = new Object();
-
-    this.events = new Object();
-
-    this.log_output(`Account Instance: ${this.name}`);
+    this.chain = new Chain(this.physical_address, this);
   }
 
-  on = (event, handler) => {
-    let handlers = this.events[event];
-    if (!handlers) {
-      handlers = new Array();
-      this.events[event] = handlers;
-    }
-    handlers.push(handler);
-  };
+  run = async (payload) => {
+    let { physical_address, query } = payload;
 
-  emit = (event, data) => {
-    let handlers = this.events[event];
-    Array.isArray(handlers) &&
-      handlers.map((handle) => this.run_callback(handle, data));
-  };
+    let chain = await this.vm.handle_chain(physical_address);
+    let codes = await chain.read(query);
 
-  propagate = (data, endpoint) => {
-    if (data.is_propagated) return;
+    await this.vm.execute(codes);
+  };
 
-    let servers = this.privileges[endpoint];
+  load = async (payload) => {
+    let { sequence: codes, physical_address } = payload;
 
-    if (data.exclusive) {
-      if (typeof data.exclusive === "boolean") return;
-      else if (Array.isArray(data.exclusive)) {
-        servers =
-          servers &&
-          servers.filter((serv) => {
-            return data.exclusive.includes(serv.domain);
-          });
-      }
-    }
+    for (let c = 0; c < codes.length; c++) {
+      let instruction = codes[c];
 
-    data.is_propagated = true;
-    data = JSON.stringify(data);
-
-    if (servers && servers.length) {
-      servers.map((serv) => {
-        post_request({
-          options: {
-            ...serv,
-            path: `/${endpoint}`,
-          },
-          data,
+      if (["function", "class"].includes(instruction.type)) {
+        let addresses = await this.load({
+          ...instruction,
+          sequence: instruction.sequence,
+          physical_address: instruction.physical_address,
         });
-      });
-    }
-  };
-
-  add_server = ({ server, privileges }) => {
-    if (!Array.isArray(privileges) && privileges)
-      privileges = ["load", "parse", "run", "create_account"];
-
-    privileges.map((privilege) => {
-      let priv = this.privileges[privilege];
-      if (!priv) {
-        priv = [];
-        this.privileges[privilege] = priv;
+        instruction.sequence = addresses;
       }
-      if (!priv.find((serv) => serv.domain === server.domain))
-        priv.push(server);
-    });
-  };
-
-  get_account = (name) => {
-    return this.manager.get_account(name) || this;
-  };
-  
-  generate_pid = ()=>{
-    return `${Date.now()}-${Math.random()}`
-  }
-
-  manage_buffer = (callback,pid ) => {
-    let call_session = pid || this.generate_pid();
-    this.mine_buffer[call_session] = { blocks: [], callback,  };
-
-    return call_session;
-  };
-
-  results = new Object()
-
-  buff = (block, pid) => {
-    if(block.ret){
-      this.results[pid] = block.ret
-      return;
-    }
-
-    let buffer = this.mine_buffer[pid];
-    if (!buffer) return;
-
-    block && block.stringify &&  buffer.blocks.push(block.stringify());
-  };
-
-  flush_buffer = (pid, payload) => {
-    let buff = this.mine_buffer[pid];
-    if (!buff) return;
-
-    if (buff.callback){
-      this.run_callback(buff.callback,{ pid, payload, ret: this.results[pid] , blocks: buff.blocks});
-    } else if(buff.real_cb){
-      buff.real_cb(payload, pid)
-    }
-
-    console.log(JSON.stringify(buff.blocks.map(b=>b.stringify())))
-    
-    this.vm.stack.pop(pid)
-    
-    delete this.mine_buffer[pid];
-    delete this.results[pid]
-  };
-
-  execute =( opcode, args)=>{
-    let circ = this.vm.opcodes[opcode]
-    if (typeof circ !== 'function') {return}
 
-    circ(args)
-  }
-
-  process_fee = ({fee, validator}, cb)=>{
-    let content = this.vm.read_chain(fee, {tell_callable})
-
-    if (content.callable){
-      this.vm.exec({executable: content.__address__, location:result=>{
-        this.vm.exec({executable: validator, location: result=>{
-          cb && cb(result)
-        }, arguments: {argc:1, argv: [{position: 0, static_value: result}]}})
-      }})
-    } else {
-      this.vm.exec({executable: validator, location: (result)=>{
-        cb && cb(result)
-      }, arguments: {argc:1, argv: [{position:0, address: fee}]}})
-    }
-  }
-  
-  load = (payload) => {
-    let { program } = payload;
-    let { instructions, physical_address } = program;
-
-    let shards = this.loader.shard_instructions(instructions, physical_address)
-
-    for (let s=0; s < shards.length; s++){
-      let shard = shards[s]
-
-      let chain = this.vm.handle_chain(shard.physical_address)
-      chain.set_obj_config({sequence: shard.instructions, __address__: shard.physical_address, ...shard.config})
+      let chain = await this.vm.handle_chain(instruction.physical_address);
+      let block = await chain.write(instruction);
+      codes[c] = block.address;
     }
-  };
-
-  parse = (program) => {
-    let { payload, callback, signature } = program;
+    let chain = await this.vm.handle_chain(physical_address);
+    await chain.write({ ...payload, sequence: codes });
 
-    this.propagate(program, "parse");
-
-    this.manager.oracle.fetch({ ...payload, signature }, (result) =>
-      this.run_callback(callback, result)
-    );
-  };
-
-  run = (request) => {
-    let { payload, callback} = request;
-
-    let { physical_address, direct, options, instructions} = payload;
-
-    let config;
-    if (!instructions){
-      console.log(`Running ${physical_address}`)
-
-      let chain = this.vm.handle_chain(physical_address)
-
-      config = this.read(chain.datapath, {callable:true})
-      if(!config) console.log('shout')
-
-      instructions = config.sequence
-    }
-    let pid = this.manage_buffer(callback, direct)
-   
-    !direct && this.vm.stack.initiate(pid)
-    
-    this.manager.push({sequence: [...instructions, 'pass'], physical_address, account: this, options, config, not_direct: !direct, pid})
+    return codes;
   };
 
-  run_callback = (callback, payload) => {
-    if (!callback) return;
+  sync = async () => {
+    this.servers = new Array();
+    this.vm = new Virtual_machine(this);
 
-    if (typeof callback === "function") return callback(payload);
+    await this.chain.sync();
+    await this.vm.sync();
 
-    callback.payload &&
-      callback.payload.physical_address &&
-      this.vm.stdin(payload, callback);
+    await register(this);
   };
-
-  flush_stdout = (block) => {
-    if (
-      block.chain.physical_address === `${this.physical_address}/Opcodes/stdout`
-    )
-      return;
-
-    for (let s = 0; s < this.stdout.length; s++) {
-      let out = this.stdout[s];
-      if (out.pid === this.vm.track.pid) {
-        block.metadata.stdout.push(out.data);
-        this.stdout[s] = null;
-      }
-    }
-    this.stdout = this.stdout.filter((out) => !!out);
-  };
-
-  validate = (payload, signature, callback) => {
-    if (!this.private) return true;
-
-    let valid = validate_signature(
-      this.name,
-      JSON.stringify(payload),
-      signature
-    );
-    if (!valid && callback)
-      this.run_callback(callback, {
-        private: this.private,
-        error: true,
-        error_message: "Invalid signature",
-      });
-
-    return valid;
-  };
-
-  stringify = (str) => {
-    let obj = {};
-
-    obj.name = this.name;
-    obj.hash = this.hash;
-    obj.path = this.path;
-    obj.private = this.private;
-    obj.chain = this.chain.stringify();
-    obj.physical_address = this.physical_address;
-
-    return str ? JSON.stringify(obj) : obj;
-  };
-
-  create_account = (payload) => {
-    this.propagate(payload, "create_account");
-    let { name, meta } = payload;
-
-    return this.manager.add_account(name, meta);
-  };
-
-  set_socket = socket => {
-    this.socket = socket;
-    socket.account = this
-  }
 }
 
 export default Account;

package/Objects/Block.js

@@ -1,97 +1,17 @@
-import { hash } from "../utils/hash";
-import { _id } from "generalised-datastore/utils/functions";
-
 class Block {
-  constructor(chain) {
+  constructor(meta, chain) {
+    this.content = meta.content;
     this.chain = chain;
-    this.data = this.chain.txs;
-    this.metadata = {};
-    this.children = new Array();
-    this.index = this.chain.height;
-    this.datahash = hash(JSON.stringify(this.data || this.chain.physical_address))
-    this.clock = this.chain.account.vm.track.clocks
-    this._id = `${this.clock}-${this.datahash}`;
-    this.previous_hash = this.chain.recent_block && this.chain.recent_block._id
-    this.generate_hash()
+    this.index = chain.blocks.length;
   }
 
-  generate_hash = () => {
-    this.hash = hash(`${this._id}`);
-  };
-
-  store = (no_curs) => {
-    let content = this.chain.buffs.splice(-1)[0];
-    if (!no_curs) this.cursor = this.chain.cursors.splice(-1)[0];
-    if (!content) return;
-
-    if (this.data.length<=1 && this.chain.account.is_datatype(this.chain)){
-      content = this.chain.account.stringify_type(this.chain)
-    }else {
-      let cursors = Object.keys(content).filter(
-        (c) => c.startsWith("{") && c.endsWith("}")
-      );
-
-      for (let c = 0; c < cursors.length; c++) {
-        let curs = cursors[c];
-
-        this.metadata[curs.slice(1, -1)] = content[curs];
-        delete content[curs];
-      }
-    }
-    
-
-    this.metadata.stdout = new Array();
-    this.chain.account.flush_stdout(this);
+  sync = async () => {
+    this.address = `${this.chain.physical_address}:${this.index}`;
 
-    if(!this.chain.datapath){
-      let datapath = this.chain.account.save(content, this.chain);
-      this.datapath = datapath
-    }else {
-      this.chain.account.save(content)
-      this.datapath = this.chain.datapath
-    }
+    await this.generate_hash();
   };
 
-  stringify = (str) => {
-    let obj = {};
-
-    obj.metadata = this.metadata;
-    obj.datapath = this.datapath;
-    obj.timelapse = this.timelapse;
-    obj.index = this.index;
-    obj.hash = this.hash;
-    obj.previous_hash = this.previous_hash;
-    obj.data = this.data;
-    obj._id = this._id;
-    obj.clock = this.clock;
-    obj.datapath = this.datapath;
-    obj.children = this.children.map((ch) => ch && ch._id);
-    obj.chain = {
-      hash: this.chain.hash,
-      physical_address: this.chain.physical_address,
-    };
-
-    return str ? JSON.stringify(obj) : obj;
-  };
-
-  static build = (data, chain) => {
-    let blck = new Block(chain);
-    blck.chain = chain;
-    blck.metadata = data.metadata || {};
-    blck.datapath = data.datapath;
-    blck.timelapse = data.timelapse;
-    blck.index = data.index;
-    blck.data = data.data;
-    blck.children = data.children || [];
-
-    if (data._id) blck._id = data._id;
-    if (data.clock != null) blck.clock = data.clock
-    if (data.hash) blck.hash = data.hash
-    if (data.previous_hash) blck.previous_hash = data.previous_hash
-    if (data.datahash) blck = blck.datahash
-
-    return blck;
-  };
+  generate_hash = async () => {};
 }
 
 export default Block;