godprotocol 1.1.0 → 1.1.2

package/Executables/functions/servers/account.js

@@ -1,81 +0,0 @@
-const connect = (args, vm, options)=>{
-  let {name, meta} = args;
-
-  if (name.__classifier__ !== vm.get_type_address('string')){
-    return vm.stderr({name:'Type_error', message: 'Account name must be a string'})
-  }
-  if (meta.__classifier__ !== vm.get_type_address('twain')){
-    return vm.stderr({name:'Type_error', message: 'Account name must be a twain'})
-  }
-
-  name = vm.display(name)
-  meta = vm.display(meta)
-
-  let result = vm.account.manager.add_account(name, {...meta, string:true})
-
-  vm.air_object(result, options)
-}
-
-const load = (args, vm, options)=>{
-  let {account, payload} = args;
-
-  if (account.__classifier__ !== vm.get_type_address('account')){
-    return vm.stderr({name:'Type_error', message: 'account must be an Account instance'})
-  }
-  if (payload.__classifier__ !== vm.get_type_address('twain')){
-    return vm.stderr({name:'Type_error', message: 'Payload must be a twain'})
-  }
-
-  account = vm.display(account, )
-  payload = vm.display(payload, )
-
-  vm.account.manager.endpoint('load', payload, (response)=>{
-    vm.air_object(response, options)
-  })
-}
-
-const run = (args, vm, options)=>{
-  let {account, payload} = args;
-
-  if (account.__classifier__ !== vm.get_type_address('account')){
-    return vm.stderr({name:'Type_error', message: 'account must be an Account instance'})
-  }
-  if (payload.__classifier__ !== vm.get_type_address('twain')){
-    return vm.stderr({name:'Type_error', message: 'Payload must be a twain'})
-  }
-
-  account = vm.display(account)
-  payload = vm.display(payload)
-
-  vm.account.manager.endpoint('run', payload, (response)=>{
-    vm.air_object(response, options)
-  })
-}
-
-const parse = (args, vm, options)=>{
-  let {account, payload} = args;
-
-  if (account.__classifier__ !== vm.get_type_address('account')){
-    return vm.stderr({name:'Type_error', message: 'account must be an Account instance'})
-  }
-  if (payload.__classifier__ !== vm.get_type_address('twain')){
-    return vm.stderr({name:'Type_error', message: 'Payload must be a twain'})
-  }
-
-  account = vm.display(account)
-  payload = vm.display(payload)
-
-  vm.account.manager.endpoint('parse', payload, (response)=>{
-    vm.air_object(response, options)
-  })
-}
-
-const servers = (args, vm, options) => {
-  let {account} = args;
-  account = vm.display(account, (res)=>{
-    let acc = vm.account.manager.get_account(res.name);
-    vm.air_object(acc.get_servers(), options)
-  })
-}
-
-export {run, load, servers, parse, connect}

package/Executables/functions/servers/account_register.js

@@ -1,56 +0,0 @@
-import { connect, load, parse, run, servers } from "godprotocol/Executables/functions/servers/account";
-
-const account_register = (account)=>{
-  let add_callable = account.vm.add_callable;
-
-  add_callable('connect_', {
-    callable: connect,
-    config: {
-      parameters: [
-        {name:'name', position:0},
-        {name:'meta', position:1},
-      ]
-    }
-  })
-
-  add_callable('load_', {
-    callable: load,
-    config: {
-      parameters: [
-        {name:'account', position:0},
-        {name:'payload', position:1},
-      ]
-    }
-  })
-
-  add_callable('parse_', {
-    callable: parse,
-    config: {
-      parameters: [
-        {name:'account', position:0},
-        {name:'payload', position:1},
-      ]
-    }
-  })
-
-  add_callable('run_', {
-    callable: run,
-    config: {
-      parameters: [
-        {name:'account', position:0},
-        {name:'payload', position:1},
-      ]
-    }
-  })
-
-  add_callable('servers_', {
-    callable: servers,
-    config: {
-      parameters: [
-        {name:'account', position:0}
-      ]
-    }
-  })
-}
-
-export default account_register;

package/Executables/functions/servers/block.js

@@ -1,21 +0,0 @@
-const get_block = (args, vm, options) =>{
-  let {hash, chain} = args;
-
-  if (hash.__classifier__ !== vm.get_type_address('string')){
-    return vm.stderr({name:"Type_error", message:"Hash must be of type string"})
-  }
-  if (chain.__classifier__ !== vm.get_type_address('chain')){
-    return vm.stderr({name:"Type_error", message:"chain must be of instance `Chain`"})
-  }
-  hash = vm.display(hash, true)
-
-  vm.display(chain, res=>{
-    let chain = vm.account.manager.web.get(res.physical_address)
-    let blk = chain.explore(JSON.stringify({blocks: hash}))
-    blk = blk && blk.stringify()
-
-    vm.air_object(blk, options)
-  })
-}
-
-export {get_block}

package/Executables/functions/servers/block_register.js

@@ -1,18 +0,0 @@
-import { get_block } from "./block";
-
-const block_register = (account)=>{
-  let add_callable = account.vm.add_callable;
-
-  add_callable('get_block_', {
-    callable: get_block,
-    config: {
-      parameters: [
-        {name:'hash', position:0},
-        {name:'chain', position:1},
-      ]
-    }
-  })
-}
-
-
-export default block_register

package/Executables/functions/servers/chain.js

@@ -1,42 +0,0 @@
-const get_chain = (args, vm, options) =>{
-  let {physical_address, account} = args;
-
-  if (account.__classifier__ !== vm.get_type_address('account')){
-    return vm.stderr({name:'Type_error', message: 'account must be an Account instance'})
-  }
-  if (physical_address.__classifier__ !== vm.get_type_address('string')){
-    return vm.stderr({name:'Type_error', message: 'physical_address must be a string'})
-  }
-
-  physical_address = vm.display(physical_address)
-
-  vm.display(account, res=>{
-    let acc = vm.account.manager.get_account(res.name)
-
-    let addr = acc.resolve_address(physical_address)
-    let chain = vm.account.manager.web.get(addr)
-
-    vm.air_object(chain && chain.stringify(), options)
-  })
-}
-
-const explore = (args, vm, options)=>{
-  let {chain, query} = args;
-
-  if (![vm.get_type_address('string'), vm.get_type_address('twain')].includes(query.__classifier__)){
-    return vm.stderr({name:"Type_error", message: "query must be of type string | twain"}) 
-  }
-  query = vm.display(query, true)
-  if(typeof query !== 'string')query = JSON.stringify(query)
-
-  vm.display(chain, res=>{
-    let chn = vm.account.manager.web.get(res.physical_address)
-    if (!chn)return vm.stderr({name: 'Chain_error', message: `${res.physical_address} not set.`})
-
-    let blk = chn.explore(query)
-
-    vm.air_object(blk && blk.stringify(), options)
-  })
-}
-
-export {get_chain, explore}

package/Executables/functions/servers/chain_register.js

@@ -1,28 +0,0 @@
-import { explore, get_chain } from "./chain";
-
-const chain_register = (account)=>{
-  let add_callable = account.vm.add_callable;
-
-  add_callable('get_block_', {
-    callable: get_chain,
-    config: {
-      parameters: [
-        {name:'physical_address', position:0},
-        {name:'account', position:1},
-      ]
-    }
-  })
-
-  add_callable('explore_', {
-    callable: explore,
-    config: {
-      parameters: [
-        {name:'chain', position:0},
-        {name:'query', position:1},
-      ]
-    }
-  })
-}
-
-
-export default chain_register

package/Executables/functions/set_error_catch.js

@@ -1,34 +0,0 @@
-const set_error_catch = (args, vm)=>{
-  // console.log(args)
-  let {object, metadata} = args
-
-  let inst = vm.track.sequence[vm.track.pointer +6]
-  inst = parseInt(inst.split(' ')[1])
-  
-  for (let o=0; o< object.length; o++){
-    let obj_addr = object[o]
-    let obj, statc;
-    if (obj_addr === '*'){
-      obj = obj_addr
-    }else{
-      obj = vm.read_chain(obj_addr)
-    }
-
-    if (obj !== '*'){
-      let name = vm.read_chain(obj.name_id)
-    
-      statc = vm.static_value(name)
-      if(statc.static_value == null){
-        return this.stderr(`Invalid argument to an Error object`)
-      }
-    }
-    
-    vm.push_int(statc? statc.static_value: obj, {object: obj, metadata, catch_pointer: inst})
-  }
-  
-  vm.track.pointer += 17
-  
-  vm.pop_context()
-}
-
-export default set_error_catch

package/Executables/functions/string_register.js

@@ -1,130 +0,0 @@
-import { case_, concat, includes, index, indexof, repeat, slice, split, trim } from "./methods/string";
-
-const string_register = (account)=>{
-  let add_callable = account.vm.add_callable;
-
-  add_callable('slice_', {
-    callable: slice,
-    config: {
-      parameters: [
-        {name:'str', position:0},
-        {name:'start', position:1},
-        {name:'end', position:2},
-      ]
-    }
-  })
-
-  add_callable('concat_', {
-    callable: concat,
-    config: {
-      parameters: [
-        {name:'str', position:0},
-        {name:'other', position:1},
-        {name:'index', position:2},
-      ]
-    }
-  })
-
-  add_callable('case_', {
-    callable: case_,
-    config: {
-      parameters: [
-        {name:'str', position:0},
-        {name:'type', position:1},
-      ]
-    }
-  })
-
-  add_callable('index_', {
-    callable: slice,
-    config: {
-      parameters: [
-        {name:'str', position:0},
-        {name:'n', position:1},
-      ]
-    }
-  })
-
-  add_callable('indexof_', {
-    callable: slice,
-    config: {
-      parameters: [
-        {name:'str', position:0},
-        {name:'char', position:1},
-      ]
-    }
-  })
-
-  add_callable('includes_', {
-    callable: slice,
-    config: {
-      parameters: [
-        {name:'str', position:0},
-        {name:'chars', position:1},
-      ]
-    }
-  })
-
-  add_callable('trim_', {
-    callable: trim,
-    config: {
-      parameters: [
-        {name:'str', position:0},
-        {name:'char', position:1},
-        {name:'type', position:2},
-      ]
-    }
-  })
-
-  add_callable('split_', {
-    callable: split,
-    config: {
-      parameters: [
-        {name:'str', position:0},
-        {name:'char', position:1}
-      ]
-    }
-  })
-
-  add_callable('repeat_', {
-    callable: repeat,
-    config: {
-      parameters: [
-        {name: 'str', position:0},
-        {name: 'n', position:1},
-      ]
-    }
-  })
-
-  add_callable('repeat_', {
-    callable: index,
-    config: {
-      parameters: [
-        {name: 'str', position:0},
-        {name: 'n', position:1},
-      ]
-    }
-  })
-
-  add_callable('repeat_', {
-    callable: indexof,
-    config: {
-      parameters: [
-        {name: 'str', position:0},
-        {name: 'char', position:1},
-      ]
-    }
-  })
-
-  add_callable('repeat_', {
-    callable: includes,
-    config: {
-      parameters: [
-        {name: 'str', position:0},
-        {name: 'chars', position:1},
-      ]
-    }
-  })
-}
-
-export default string_register

package/Executables/functions/twain_register.js

@@ -1,56 +0,0 @@
-import { entries, get, keys, set, unset } from "./methods/twain";
-
-const twain_register = (account)=>{
-  let add_callable = account.vm.add_callable;
-
-  add_callable('get_', {
-    callable: get,
-    config: {
-      parameters:[
-        {name: 'twain', position:0},
-        {name: 'prop', position:1},
-      ]
-    }
-  })
-
-  add_callable('set_', {
-    callable: set,
-    config: {
-      parameters:[
-        {name: 'twain', position:0},
-        {name: 'prop', position:1},
-        {name: 'value', position:2},
-      ]
-    }
-  })
-
-  add_callable('keys_', {
-    callable: keys,
-    config: {
-      parameters:[
-        {name: 'twain', position:0}
-      ]
-    }
-  })
-
-  add_callable('entries_', {
-    callable: entries,
-    config: {
-      parameters:[
-        {name: 'twain', position:0}
-      ]
-    }
-  })
-
-  add_callable('unset_', {
-    callable: unset,
-    config: {
-      parameters:[
-        {name: 'twain', position:0},
-        {name: 'prop', position:1},
-      ]
-    }
-  })
-}
-
-export default twain_register

package/Executables/functions/typecast.js

@@ -1,43 +0,0 @@
-const typecast =(args, vm, options)=>{
-
-  // console.log(args, 'typecast args')
-  let {type, obj}= args;
-  type = vm.static_value(type)
-  let static_type = type.static_value;
-  let result;
-
-  if (obj.hasOwnProperty('static_value')){
-    if(static_type === 'boolean'){
-      result= (!!obj.static_value)
-      
-      return {result: vm.static_cast(result, obj.__address__)};
-    } else if(static_type === 'string'){
-      result = obj.static_value.toString()
-      
-      return {result: vm.static_cast(result, obj.__address__)}
-    } else if (static_type === 'number'){
-      result = parseInt(obj.static_value)
-      if (isNaN(result)){
-        result = null
-      }
-      return {result: vm.static_cast(result, obj.__address__)};
-    }else if (static_type === 'array'){
-      if (obj.type === 'array'){
-        return {result: obj}
-      }
-    }else if (static_type === 'twain'){
-      if (obj.type === 'twain'){
-        return {result: obj}
-      }
-    }
-  } else if(obj.__print__) {
-    console.log(obj)
-    vm.exec({executable:obj.__print__, location:result=>{
-      let res = typecast({...args, obj: result}, vm)
-      res && vm.write_chain(res.result, options.location)
-    }})
-  }
-}
-
-
-export default typecast

package/Executables/functions/utils.js

@@ -1,9 +0,0 @@
-const get_address = (args, vm, options) => {
-  return vm.air_object(args.object.__address__, options)
-}
-
-const get_id = (args, vm, options) => {
-  return vm.air_object(args.object.__id__, options)
-}
-
-export {get_address, get_id}

package/Executables/stack.js

@@ -1,53 +0,0 @@
-class Stack {
-  constructor(vm){
-    this.vm = vm;
-
-    this.stacks = new Object()
-  }
-
-  has_stack = (stack)=>{
-    stack = this.stacks[stack]
-    return !!(stack && stack.length)
-  }
-
-  initiate = (stack)=>{
-    let stack_arr = this.stacks[stack]
-    if(!stack_arr){
-      stack_arr = new Array({})
-      this.stacks[stack] = stack_arr;
-    }else stack_arr.push({})
-  }
-
-  push = (stack, block)=>{
-    stack = this.stacks[stack]
-    if(!stack)return 
-    let trace = stack.slice(-1)[0]
-    
-    trace[block.chain.name] = block;
-  }
-
-  pop = (stack_name)=>{
-    let stack = this.stacks[stack_name]
-    if (!stack)return
-
-    let trace = stack.pop()
-
-    this.repopulate(stack_name)
-
-    return trace
-  }
-
-  repopulate = (stack)=>{
-    let trace = this.stacks[stack].slice(-1)[0]
-
-    for(let name in trace){
-      let block = trace[name]
-
-      let chain = this.vm.handle_chain(block.chain.physical_address)
-      chain.forge_block(block.stringify())
-    }
-  }
-}
-
-
-export default Stack