godprotocol 1.1.0 → 1.1.2

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,262 +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
-    }
+class Chain {
+  constructor(address, account) {
+    this.physical_address = address;
+    this.account = account;
+    this.blocks = new Array();
+    this.servers = new Array();
   }
 
-  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()
-  }
-
-  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) => {
-    index = index == null ? this.height -1 : index
-    let 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: _id(this.hash)}, true)
-  }
-
-  forge_block = (obj)=>{
-    obj.index = this.height
-    obj._id = _id(this.hash)
-    obj.previous_hash = this.recent_block && this.recent_block._id
-
-    let blk = this.build_block(obj, true)
-
-    this.add_block(blk)
-
-    return blk
-  }
-
-  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.generate_hash();
-    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();
-
-    data = this.account.manager.oracle.handle_compression({
-      addr: this.folder.folder_path,
-      data,
-      no_string: true,
-    });
+  write = async (payload) => {
+    let address = await this.account.manager.oracle.write(payload);
 
-    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"})
-    }
+    let block = new Block({ content: address }, this);
+    await block.sync();
 
-    this.folder.write(data);
-  }
-
-  add_block = (block) => {
     this.blocks.push(block);
-    this.height++;
-
-    if (!this.physical_address.startsWith(`${this.account.physical_address}/Opcodes`) &&  Array.from(Object.keys(block.metadata)).length){
-      this.persist(block)
-    }
-
-    this.recent_block = block;
-
-    if (this.account.initiated){
-      let parent_addr = this.parent.physical_address
-      if (this.account.vm.stack.has_stack(parent_addr)){
-        this.account.vm.stack.push(parent_addr, 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,316 +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 Logger from "../utils/logger";
-import Protocol from "godprotocol/Objects/Protocol";
+import Repository from "./Repository";
 
+class Manager {
+  constructor(name, options) {
+    this.name = name;
+    this.options = options || {};
 
-class Manager extends Protocol{
-  constructor(meta) {
-    super()
-    
-    meta = meta || {};
-
-    this.compression = meta.compression;
-    this.frequency = meta.frequency
-    this.manager_id = _id("manager");
-    this.accounts = new Object();
-    this.running = 0;
-    this.logger = new Logger()
-    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"
-  }
-
-  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);
   }
 
-  state_logger = ()=>{
-    let lines=0
-    for (let account in this.accounts_et_programs){
-      let payload = this.accounts_et_programs[account];
-      let tracks = payload.tracks
-
-      console.log(`(${payload.clocks}) Account: ${account} [tracks(${tracks.length})]`)
-
-      let curr_track = tracks.slice(-1)[0]
-      let pointer = curr_track.pointer
-      let instruction = curr_track.sequence[pointer]
-
-      console.log(`>(${curr_track.clocks}) Track [${pointer} / ${curr_track.sequence.length}] - executing '${instruction}'`)
-      lines+=2
+  sync = async () => {
+    if (this.server && !this.server.domain) {
+      this.server.domain = `${this.server.hostname}:${this.server.port}`;
     }
-    return lines
-  }
-
-  finish_state = ()=>{
-    console.log(`All programs finished execution`)
-  }
-
-  start_clock = () => {
-    let frequency = Number(this.frequency)|| Number(process.env.HERTS) || 10;
-    this.clock = setInterval(() => {
-      
-      for (let account in this.accounts_et_programs) {
-        let payload = this.accounts_et_programs[account], spawn, tracks;
-
-        if(payload.spawn_list.length){
-          if(payload.spawn_cursor == undefined){
-            payload.spawn_cursor = 0
-            tracks = payload.tracks;
-          }else {
-            spawn = payload.spawn_list[payload.spawn_cursor]
-            tracks = payload.spawns[spawn];
-            payload.spawn_cursor ++
-          }
-        }else {
-          tracks = payload.tracks;
-        }
+    this.server_object =
+      this.server && (await create_server({ ...this.server, manager: this }));
 
-        let program = tracks.slice(-1)[0];
+    this.post_request = post_request;
 
-        payload.clocks ++
-        if (program.hold) continue;
-
-        let instruction = program.sequence[program.pointer];
-        program.clocks++
-
-        program.pointer++;
-        program.account.vm.execute(instruction, program);
-        program = program.account.vm.track;
-        
-        if (program.pointer >= program.sequence.length) {
-          program.account.flush_buffer(program.pid);
-
-          if (program.error_stack)
-            program.account.vm.error_manager = JSON.parse(program.error_stack)
-          tracks.pop();
-
-          if(spawn){
-            if (payload.spawn_cursor >= payload.spawn_list.length){
-              payload.spawn_cursor = undefined
-            }
-          }
-        }
-        if (!tracks.length) {
-          if (spawn){
-            delete payload.spawns[spawn]
-            payload.spawn_list = payload.spawn_list.filter(s=>s!==spawn)
-          }else {
-            this.running -= 1;
-            delete this.accounts_et_programs[account];
-            program.account.chain.mine(program.account.vm);
-          }
-          
-        }
-      }
-
-      this.logger.log(this.state_logger)
-      if (!this.running){
-        clearInterval(this.clock)
-       this. finish_state(this.finish_state)
-      }
-    }, frequency);
+    await this.repository.sync(this.name);
   };
 
-  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);
+  add_account = async (name, options) => {
+    let account = this.accounts[name];
 
-      if (!account) {
-        account = new Account(name, { ...meta, manager: this });
+    if (account) return account;
 
-        opcodes(account);
-        framer(account, meta.on_framed);
+    account = new Account(name, { ...options, manager: this });
+    await account.sync();
 
-        this.accounts[account.name] = account;
-        if (meta.string) account = account.stringify();
-      } else if (meta && meta.private && !account.private) {
-        account.private = true;
-      }
-    }
-
-    return meta.string ? JSON.stringify(account) : 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)
-      }else tracks=  account.tracks
-      if(program.unshift){
-        delete program.unshift
-        tracks.unshift({ ...program, pointer: 0, clocks:0 });
-      } else tracks.push({ ...program, pointer: 0, clocks:0 });
-    } 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.accounts_et_programs[program.account.name] = account;
-
-      this.running++;
-      this.running === 1 && this.start_clock();
-    }
-  };
-
-  get_initiator = () => this.initiator || this.initiate();
-
-  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.validate(
-        payload.program || payload.payload,
-        payload.signature,
-        callback || payload.callback
-      )
-    )
-      return;
-
-    let method = account[endpoint];
-    typeof method === "function" && method({ ...payload, callback });
-  };
-
-  add_server = (server) => {
-    this.servers.push(server);
+    this.accounts[name] = account;
   };
-
-  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);
-    url = split[0].split('/').filter(a=>!!a)
-
-    if (url.length> 2){}
-
-    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;