godprotocol 1.1.1 → 1.1.2

package/Objects/Blockweb.js

@@ -1,46 +1,33 @@
 import Chain from "./Chain";
 
 class Blockweb {
-  constructor(mgr) {
-    this.mgr = mgr;
-    this.physical_addresses = new Object();
+  constructor(manager) {
+    this.manager = manager;
+
     this.chains = new Object();
+    this.listeners = new Object();
   }
 
-  get = (addr) => {
-    let hash = this.physical_addresses[addr];
-
-    let chain = this.chains[hash];
-
-    return chain;
-  };
-
-  split_set = (physical_address) => {
-    if(physical_address.includes('{'))throw new Error()
-    
-    let spli = physical_address.split("/");
-
-    let chain = this.get(physical_address);
-    if (!chain && spli.length >1) {
-      if (spli.length === 2){
-        if (physical_address.startsWith('Accounts/')){
-          chain = this.mgr.add_account(spli[1]).chain
-        }
-      }else chain = this.set(spli.slice(0, -1).join("/"), spli.slice(-1)[0]);
+  listen = async (physical_address, config) => {
+    let ls = this.listeners[physical_address];
+    if (!ls) {
+      ls = new Array();
+      this.listeners[physical_address] = ls;
     }
-    return chain;
+    ls.push(config.server);
   };
 
-  set = (parent, name) => {
-    if (typeof parent === "string") {
-      parent = this.get(parent) || this.split_set(parent);
-    }
+  spli_get = async (address, account) => {
+    return this.get(address) || (await this.set(address, account));
+  };
 
-    let chain = new Chain(parent, name);
-    this.chains[chain.hash] = chain;
+  get = (address) => {
+    return this.chains[address];
+  };
 
-    this.physical_addresses[chain.physical_address] = chain.hash;
-    this.chains[chain.hash] = chain;
+  set = async (address, account) => {
+    let chain = new Chain(address, account);
+    await chain.sync();
 
     return chain;
   };

package/Objects/Callable.js

@@ -0,0 +1,40 @@
+class Callable {
+  constructor() {
+    this.objects = new Object();
+  }
+
+  parse_arguments = async (payload, config) => {
+    let { args } = payload;
+    let aggs = new Object();
+
+    for (let a = 0; a < args.length; a++) {
+      let arg = args[a];
+
+      let content = await this.read_chain(arg),
+        param;
+      if (content.type === "variable") {
+        param = config.parameters.find((p) => p.name === content.identifier);
+
+        if (!param) return await this.stderr({ name: "unidentified_argument" });
+
+        content = await this.read_chain(content.value);
+      } else param = config.parameters[a];
+
+      aggs[param.name] = content;
+    }
+
+    return aggs;
+  };
+
+  callable = async (name) => {
+    let object = this.objects[name];
+
+    return object;
+  };
+
+  set = (name, config) => {
+    this.objects[name] = config;
+  };
+}
+
+export default Callable;

package/Objects/Chain.js

@@ -1,273 +1,38 @@
-import { _id } from "generalised-datastore/utils/functions";
-import { hash } from "../utils/hash";
 import Block from "./Block";
-import Explorer from "./Explorer";
 
-class Chain extends Explorer {
-  constructor(parent, name) {
-    super();
-    
-    this.parent = parent;
-    this.account = this.parent.account;
-    this.name = name || this.parent.name;
-    
-    this.physical_address =
-      this.parent.manager || !name
-        ? this.parent.physical_address
-        : `${this.parent.physical_address}/${this.name}`;
-
-    this.pending_children = new Array();
-    this.connections = new Array();
-    
-    this.txs = new Array();
-
-    this.height = 0;
-    this.cursor = -1;
-    this.cursors = new Array();
-    this.buffs = new Array();
-
-    this.generate_hash();
-
-    this.folder = this.account.manager.oracle.gds.folder(this.hash);
-    this.height = this.folder.config.stats.files;
-    this.blocks = new Array(this.height);
-
-    if (this.folder.config.stats.chain)
-    this.datapath = this.folder.config.stats.chain.datapath
-
-    // console.log(this.folder.config)
-
-    this.account.set_paths(this);
-
-    this.manage_config(true);
-
-    if (this.folder.config.stats.recent_file){
-      this.recent_block = this.build_block(this.folder.config.stats.recent_file);
-      this.blocks[this.recent_block.index] = this.recent_block
-    }
-  }
-
-  manage_config = (init) => {
-    if (init) {
-    }
-
-    this.folder.config.add_entry("chain", this.stringify());
-  };
-
-  set_fee = ({purpose, fee, validator})=>{
-    this.fees.set({purpose, fee, validator})
-  }
-
-  get_fee = purpose =>{
-    return this.fees.get(purpose)
-  }
-
-  pay = (purpose, payer, cb) =>{
-    let account = this.account.manager.get_account(payer)
-    let token = this.get_fee(purpose)
-
-    account.process_fee(token, cb)
-  }
-
-  set_obj_config = config=>{
-    let addr = typeof config === 'string'? config: this.account.save(config)
-    
-    this.datapath = addr;
-    this.manage_config()
-
-    return addr;
-  }
-
-  clear_config = ()=>{
-    this.datapath = ''
-    this.manage_config()
-
-    return this
-  }
-
-  append_buffer = () => {
-    this.buffs.push({});
-    this.cursors.push(this.cursor);
-    this.cursor = -1;
-  };
-
-  set_cursor = (cursor) => {
-    this.cursor = cursor;
-    this.cursors.push(cursor);
-  };
-
-  get_buffer = () => {
-    this.cursor = this.cursors.pop();
-    return this.buffs.slice(-1)[0];
-  };
-
-  generate_hash = () => {
-    this.hash = hash(this.physical_address);
-  };
-
-  build_block = (blk, forge) => {
-    if (typeof blk === "string") {
-      let blk_data = this.folder.readone(blk, { depth: 1 });
-
-      if (blk_data){
-        blk = Block.build(blk_data, this);
-      }
-    }else if (forge){
-      if(!blk.hash) blk.hash = hash(JSON.stringify(blk))
-      blk = Block.build(blk, this)
-    }
-    return blk;
-  };
-
-  traverse_blocks = (stop) => {
-    let blk =  this.blocks.slice(stop).find(b=>b && b._id);
-    
-    while (blk&& blk.index !== stop) {
-      blk = this.build_block(blk.previous_hash);
-      
-    }
-    return blk;
-  };
-
-  get_block = (index) => {
-    let blk;
-    if(!index && index !== 0){
-      blk = this.account.vm.stack.retrieve(this.physical_address)
-      if (blk)return blk
-    }
-
-    index = index == null ? this.height -1 : index
-    blk = this.blocks[index];
-
-    if(blk) blk = this.build_block(blk);
-
-    if (!blk||(blk&& blk.index !== index)) {
-      console.log("Twisted chain", index,blk&& blk.index, this.physical_address);
-      if (index < this.height) {
-        blk = this.traverse_blocks(index);
-      }
-    }
-    if(blk&& !isNaN(Number(blk.index)))this.blocks[blk.index] = blk
-
-    return blk;
-  };
-
-  add_tx = (instruction) => {
-    if (!this.txs.length) this.start_time = Date.now();
-
-    this.txs.push(instruction);
-  };
-
-  fabricate_datapath_block=()=>{
-    if(!this.datapath)return this.stderr({"name":"Chain_error",'message':'Cannot fabricate datapath block of no-call chain'})
-
-    return this.build_block({metadata:{output:this.datapath}, index:0, _id: this.account.vm.track.clocks}, true)
-  }
-
-  forge_block = (obj, options)=>{
-    obj.index = this.height
-    obj.previous_hash = this.recent_block && this.recent_block._id
-
-    let blk = this.build_block(obj, true)
-
-    this.add_block(blk, options)
-
-    return blk
+class Chain {
+  constructor(address, account) {
+    this.physical_address = address;
+    this.account = account;
+    this.blocks = new Array();
+    this.servers = new Array();
   }
 
-  mine = (vm, no_curs) => {
-
-    if (this.physical_address === `${this.account.physical_address}/Datatypes/Void` && this.height){
-      let blk = this.get_latest_block()
-      vm.connect_block(blk)
-
-      return blk
-    }
-
-    let block = new Block(this);
-
-    block.store(no_curs);
-
-    block.children = this.pending_children;
-    this.pending_children = new Array();
-
-    block.timelapse = Date.now() - this.start_time;
-
-    this.add_block(block);
-
-    vm.connect_block(block)
-
-    this.txs = new Array();
-
-    this.manage_config();
-
-    return block;
+  sync = async () => {
+    this.folder = await this.account.manager.oracle.folder(
+      this.physical_address
+    );
   };
 
-  persist = block=>{
-    let data = block.stringify();
+  write = async (payload) => {
+    let address = await this.account.manager.oracle.write(payload);
 
-    data = this.account.manager.oracle.handle_compression({
-      addr: this.folder.folder_path,
-      data,
-      no_string: true,
-    });
+    let block = new Block({ content: address }, this);
+    await block.sync();
 
-    if(!data.previous_hash &&data.index!==0){
-      console.log(data)
-      return this.account.vm.stderr({name:"Chain_error", message:"chain corruption, as a non index 0 block is without a previous_hash"})
-    }
-
-    this.folder.write(data);
-  }
-
-  add_block = (block, options) => {
-    options = options || {}
-
-    console.log(block.stringify())
-
-    if (!block._id){
-      throw new Error()
-    }
     this.blocks.push(block);
-    this.height++;
-
-    this.account.vm.stack.push(block, options.prev_track)
-
-    this.recent_block = block;
   };
 
-  get_latest_block = () => {
-    let blk = this.recent_block;
+  read = async (query) => {
+    let { index } = query;
 
-    return this.build_block(blk);
-  };
-
-  stringify = (str) => {
-    let obj = {};
-
-    obj.physical_address = this.physical_address;
-    obj.height = this.blocks.length;
-    obj.parent = this.parent.path;
-    obj.account = this.parent.account.name;
-    obj.name = this.name;
-    obj.datapath = this.datapath
-    obj.connections = this.connections.map((b) =>
-      b.stringify
-        ? new Object({
-            chain: b.chain.hash,
-            block: { hash: b.hash, _id: b._id },
-          })
-        : b
-    );
-    obj.hash = this.hash;
-    // obj.blocks = this.blocks.map((blk) => blk.hash || blk);
+    if (index != null) return await this.get_block(index);
 
-    return str ? JSON.stringify(obj) : obj;
+    return await this.get_block();
   };
 
-  add_chain = (name) => {
-    return this.account.add_chain(name, this);
+  get_block = async (index) => {
+    return this.blocks[index == null ? this.blocks.length - 1 : index];
   };
 }
 

package/Objects/GDS/Arena_classic/.config

@@ -0,0 +1 @@
+{"servers":[{"port":1408,"hostname":"127.0.0.1","repo":true,"domain":"127.0.0.1:1408"},{"port":1409,"hostname":"127.0.0.1","repo":true,"domain":"127.0.0.1:1409"}]}

package/Objects/GDS/Arena_classic/Accounts/lola/.config

@@ -0,0 +1 @@
+{"servers":[{"port":1408,"hostname":"127.0.0.1","repo":true,"domain":"127.0.0.1:1408"},{"port":1409,"hostname":"127.0.0.1","repo":true,"domain":"127.0.0.1:1409"}]}

package/Objects/Manager.js

@@ -1,235 +1,50 @@
-import { _id } from "generalised-datastore/utils/functions";
-import framer from "../framer";
-import opcodes from "../opcodes";
+import create_server from "../utils/create_server";
+import { post_request } from "../utils/services";
 import Account from "./Account";
 import Blockweb from "./Blockweb";
 import Oracle from "./Oracle";
-import Clock from "./Clock";
-import Protocol from "../Protocol/Protocol";
+import Repository from "./Repository";
 
-class Manager extends Protocol {
-  constructor(meta) {
-    super()
-    
-    meta = meta || {};
+class Manager {
+  constructor(name, options) {
+    this.name = name;
+    this.options = options || {};
 
-    this.compression = meta.compression;
-    this.manager_id = _id("manager");
-    this.accounts = new Object();
-    this.root = meta.root || __dirname;
-    this.accounts_et_programs = new Object();
-    this.web = new Blockweb(this);
-    this.oracle = new Oracle(this, {
-      compression: this.compression,
-      datastore: meta.datastore,
-    });
-    this.servers = new Array();
-    this.init_name = meta.initiator|| process.env.INITIATOR || "initiator"
-
-    this.clock = new Clock({frequency: meta.frequency, mgr:this})
-  }
-
-  stringify = (str) => {
-    let obj = {
-      _id: this.manager_id,
-      servers: this.servers,
-    };
-
-    return str ? JSON.stringify(obj) : obj;
-  };
-
-  initiate = (meta) => {
-    this.initiator = this.add_account(
-     this.init_name,
-      meta
-    );
-
-    return this.initiator;
-  };
-
-  set_track = ({account, physical_address, pointer}, slice)=>{
-    let payload = this.accounts_et_programs[account], t, track;
-    
-    for(t= payload.tracks.length-1; t>=0; t--){
-      let trck = payload.tracks[t]
-      if (trck.payload.physical_address === physical_address){
-        track = trck
-        break
-      }
+    this.sync_server = options.sync_server;
+    if (this.sync_server && !this.sync_server.domain) {
+      this.sync_server.domain = `${this.sync_server.hostname}:${this.sync_server.port}`;
     }
+    this.server = options.server;
+    this.accounts = new Object();
 
-    if(slice && track){
-      payload.tracks.splice(t+1)
-    }
-    if(pointer != null){
-      track.pointer = pointer;
-    }
+    this.oracle = new Oracle(this);
+    this.web = new Blockweb(this);
 
-    return track
+    this.repository = new Repository(this);
   }
 
-  get_account = (name) => this.accounts[name];
-
-  add_account = (name, meta) => {
-    meta = meta || {};
-    if (!name) name = meta.name;
-
-    let account;
-    if (!name) {
-      account = { error: true, error_message: "Name cannot be blank" };
-    } else {
-      account = this.get_account(name);
-
-      if (!account) {
-        account = new Account(name, { ...meta, manager: this });
-
-        opcodes(account);
-        framer(account, meta.on_framed);
-
-        this.accounts[account.name] = account;
-        if (meta.string) account = account.stringify();
-      } else if (meta && meta.private && !account.private) {
-        account.private = true;
-      }
+  sync = async () => {
+    if (this.server && !this.server.domain) {
+      this.server.domain = `${this.server.hostname}:${this.server.port}`;
     }
+    this.server_object =
+      this.server && (await create_server({ ...this.server, manager: this }));
 
-    return meta.string ? account.stringify(true) : account;
-  };
-
-  push = (program) => {
-    let account = this.accounts_et_programs[program.account.name];
-    let tracks ;
-
-    if (account) {
-      if (program.spawn) {
-        tracks = account.spawns[program.spawn]
-        if (!tracks) {
-          tracks = []
-          account.spawns[program.spawn] = tracks;
-        }
-        account.spawn_list.push(program.spawn)
-        tracks.push({ ...program, pointer: 0, clocks:0 });  
-      }else{
-          tracks=  account.tracks
-          let prev_track = tracks.slice(-1)[0]
-
-         tracks.push({ ...program, pointer: 0, clocks:0, prev_track: prev_track && prev_track.pid });  
-      }
-    } else {
-      tracks = [{ ...program, pointer: 0, clocks:0 }];
-      account = {
-        clocks:0,
-        spawns: {},
-        spawn_list: []
-      }
-      if (program.spawn){
-        account.spawns[program.spawn] = tracks
-        account.spawn_list.push(program.spawn)
-      }else account.tracks = tracks;
+    this.post_request = post_request;
 
-      this.accounts_et_programs[program.account.name] = account;
-
-      this.clock.inc()
-      this.clock.running === 1 && this.clock.start_clock();
-    }
+    await this.repository.sync(this.name);
   };
 
-  get_initiator = () => this.initiator || this.initiate();
+  add_account = async (name, options) => {
+    let account = this.accounts[name];
 
-  endpoint = (endpoint, payload, callback) => {
-    let account = this.get_account(payload.account);
-    if (!account && payload.account) {
-      return this.get_initiator().run_callback(callback, {
-        error: true,
-        error_message: "Account is not found",
-        payload,
-        endpoint,
-      });
-    }else account = this.get_initiator()
+    if (account) return account;
 
-    if (
-      !account.validate(
-        payload.program || payload.payload,
-        payload.signature,
-        callback || payload.callback
-      )
-    )
-      return;
+    account = new Account(name, { ...options, manager: this });
+    await account.sync();
 
-    let method = account[endpoint];
-    typeof method === "function" && method({ ...payload, callback });
+    this.accounts[name] = account;
   };
-
-  add_server = (server) => {
-    this.servers.push(server);
-  };
-
-  prepare_query  = query=>{
-    query = query.split('&');
-    let obj = {}
-    for (let q=0; q< query.length; q++){
-      let [prop, value] = query[q].split('=')
-
-      if (prop === 'executable'){
-        obj.executable = value;
-      }else if (prop.startsWith('arguments')){
-        if (!obj.arguments) obj.arguments = {argv: []}
-        if (prop.includes('.')){
-          prop = prop.split('.')
-          if (prop[2] ==='$'){
-            try{
-              value = JSON.parse(value)
-            }catch(e){}
-          }
-          obj.arguments.argv.push({name: prop[1], [prop[2]==='$'?'static_value':'address']: value})
-        } else {
-          obj.arguments.argv.push({address:value, position: obj.arguments.argv.length})
-        }
-        obj.arguments.argc = obj.arguments.argv.length
-      }else if (prop === 'location'){
-        obj.location = value;
-      }else if (prop === 'metadata'){
-        try {
-          obj.metadata  = JSON.parse(value);  
-        } catch (e) {}
-      }
-    }
-    
-    return obj;
-  }
-
-  handle_route = ({req,res, data})=>{
-    let url = req.url;
-    let split = url.split('?')
-    let query = split[1]
-
-    let payload = data || this.prepare_query(query);
-
-    if (url.startsWith('/retrieve_large_payload')){
-      this.rt.resolve_buff(res, data)
-    }else {
-      url = split[0].split('/').filter(a=>!!a)
-
-      if (url.length> 2){
-        console.log("MEEE")
-      }
-
-      let account = this.get_account(data && data.account || url[1]);
-      if(!account){
-        return res.end(JSON.stringify({error:true, error_message:"Account is not found!"}))
-      }
-
-      if (['display', 'read_chain'].includes(payload.executable )){
-        if (!payload.metadata)payload.metadata = {}
-        payload.metadata.raw = true;
-      }
-
-      let response = account.vm.exec(payload)
-
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify(response))
-    }
-  }
 }
 
 export default Manager;