godprotocol 1.0.7991 → 1.1.0

package/Executables/functions/methods/string.js

@@ -0,0 +1,197 @@
+import typecast from "../typecast";
+
+const slice = (args, vm, options)=>{
+  let {str, start, end} = args;
+
+  if(start.__classifier__ !== vm.get_type_address('number')){
+    return {result:str}
+  }else start = vm.static_value(start)
+
+  if(!end || (end && end.__classifier__ !== vm.get_type_address('number'))){
+    end = {static_value: undefined}
+  }else end = vm.static_value(end)
+
+  vm.exec({executable:str.__print__, location:(result)=>{
+    let new_val = result.static_value.slice(start.static_value, end.static_value)
+
+    vm.air_object(new_val, options)
+  }})  
+}
+
+const case_ = (args, vm, options)=>{
+  let {str, type} = args;
+
+  if(str.__classifier__ !== vm.get_type_address('string')){
+    return {result:null}
+  }
+  if (type.__classifier__ !== vm.get_type_address('number')){
+    return {result: str}
+  }else type = vm.static_value(type)
+
+  vm.exec({executable: str.__print__, location:(result)=>{
+   let new_val = result.static_value;
+
+   switch(type.static_value){
+    case 1:
+      new_val = new_val.toUpperCase()
+      break;
+    case 2:
+      new_val = new_val.toLowerCase()
+      break;
+    case 3:
+      let nv = new_val.split(' ')
+      new_val = ''
+      nv.map(n=>{
+        new_val = `${new_val} ${n[0].toUpperCase()}${n.slice(1).toLowerCase()}`
+      })
+      new_val = new_val.trim()
+      break;
+    default:;
+   }
+   
+   vm.air_object(new_val, options)
+  }})
+
+}
+
+const concat_ = (str, other, index)=> {
+  if (index === undefined || index > str.length) {
+      index = str.length;
+  }
+  
+  let start = str.slice(0, index);
+  let end = str.slice(index);
+  
+  str = `${start}${other}${end}`;
+  return str;
+}
+
+const concat = (args, vm, options)=>{
+  let {str, other, index} = args;
+
+  if (other.__classifier__ !== vm.get_type_address('string')){
+    other = typecast({obj: vm.static_value(other), type: {static_value:'string'}})
+  }
+  if (!index || (index && index.__classifier__ !== vm.get_type_address('number')))
+  index = {static_value:undefined}
+  else index = vm.static_value(index)
+
+  vm.exec({executable: str.__print__, location: result=>{
+    let res = concat_(result.static_value, other.static_value, index.static_value)
+    vm.air_object(res, options)
+  }})
+}
+
+
+const index = (args, vm, options)=>{
+  let {str, n} = args;
+
+  if (n.__classifier__ !== vm.get_type_address('number')){
+    return vm.air_object(null, options)
+  }else n = vm.static_value(n)
+
+  vm.exec({executable: str.__print__, location:result=>{
+    vm.air_object(result.static_value[n.static_value] || null, options)
+  }})
+}
+
+
+const indexof = (args, vm, options)=>{
+  let {str, char} = args;
+
+  if (char.__classifier__ !== vm.get_type_address('string')){
+    return vm.air_object(-1, options)
+  }else char = vm.static_value(char)
+
+  vm.exec({executable: str.__print__, location: result=>{
+    vm.air_object(result.static_value.indexOf(char.static_value), options)
+  }})
+}
+
+
+const includes = (args, vm, options)=>{
+  let {str, chars} = args;
+
+  if (chars.__classifier__ !== vm.get_type_address('string')){
+    return vm.air_object(false, options)
+  }else chars = vm.static_value(chars)
+
+  vm.exec({executable: str.__print__, location: result=>{
+    vm.air_object(result.static_value.includes(chars.static_value), options)
+  }})
+}
+
+const split = (args, vm, options)=>{
+  let {str, char} = args;
+
+  if (!char){
+    if (char.__classifier__ !== vm.get_type_address('string')){
+      return vm.air_object([str], {...options, flat:true})
+    }else char = vm.static_value(char)
+  }else char = {static_value: ' '}
+
+  vm.exec({executable: str.__print__, location: result=>{
+    vm.air_object(result.static_value.split(char.static_value), options)
+  }})
+ 
+}
+
+ const trim_start=(str, chars)=> {
+  let regex = new RegExp(`^[${chars}]+`, 'g');  
+  return str.replace(regex, '');
+}
+
+ const trim_end=(str, chars)=> {
+  let regex = new RegExp(`[${chars}]+$`, 'g');  
+  return str.replace(regex, '');
+}
+
+ const trimmer=(str, chars)=> {
+  return trim_start(trim_end(str, chars), chars);  
+}
+
+const trim = (args, vm, options) =>{
+  let {str, char, type} = args;
+
+  if (!char || (char.__classifier__ !== vm.get_type_address('string'))){
+    char = {static_value: ' '}
+  }else char = vm.static_value(char)
+
+  if ( !type || (type.__classifier__ !== vm.get_type_address('number'))) type = {static_value: 0} 
+  else type = vm.static_value(type)
+
+  vm.exec({executable: str.__print__, location: result=>{
+    let val = result.static_value
+    switch(type.static_value){
+      case 0:
+        val = trimmer(val, char.static_value)
+        break;
+      case 1:
+        val = trim_start(val, char.static_value)
+        break;
+      case 2:
+        val = trim_end(val, char.static_value)
+        break;
+    }
+    vm.air_object(val, options)
+  }})
+}
+
+const repeat = (args, vm, options)=>{
+  let {str,n } = args
+
+  if (!n){
+    return {result:str}
+  }
+  if (n.__classifier__ !== vm.get_type_address('number')){
+    return vm.air_object(null, options)
+  }
+
+  n = vm.static_value(n)
+
+  vm.exec({executable: str.__print__, location: result => {
+    vm.air_object(result.static_value.repeat(n.static_value), options)
+  }})
+}
+
+export {slice, index, indexof, concat, case_, split, trim, repeat, includes}

package/Executables/functions/methods/twain.js

@@ -0,0 +1,148 @@
+let hash_for_twain = (str, vm) => {
+  let hash = vm.account.manager.oracle.hash;
+  let val = hash(str, "sha-1");
+
+  if (!isNaN(parseInt(val[0]))) val = `_${val.slice(0, -1)}`;
+
+  return val;
+};
+
+const get = (args, vm, options) => {
+  let { twain, prop } = args;
+
+  if (twain.__classifier__ !== vm.get_type_address("twain")) {
+    return vm.stderr({
+      name: "Type_error",
+      message: "Must be of type `twain`",
+    });
+  }
+
+  let static_twain = vm.static_value(twain);
+
+  vm.exec({
+    executable: prop.__print__,
+    location: (prop_result) => {
+      prop_result = vm.static_value(prop_result);
+
+      let val = hash_for_twain(prop_result.static_value, vm);
+
+      let pair = static_twain.static_value[val];
+      if (!pair) vm.air_object(null, options);
+      else {
+        let value = vm.read_chain(pair[1], { tell_callable: true });
+        vm.write_chain(value.output, options.location, {
+          is_callable: value.callable,
+        });
+      }
+    },
+  });
+};
+
+const set = (args, vm, options) => {
+  let { twain, prop, value } = args;
+
+  if (twain.__classifier__ !== vm.get_type_address("twain")) {
+    return vm.stderr({
+      name: "Type_error",
+      message: "Must be of type `twain`",
+    });
+  }
+
+  let static_twain = vm.static_value(twain);
+
+  if (
+    ![
+      vm.get_type_address("number"),
+      vm.get_type_address("string"),
+      vm.get_type_address("boolean"),
+      vm.get_type_address("void"),
+    ].includes(prop.__classifier__)
+  ) {
+    return vm.stderr({
+      name: "Key_error",
+      message: "Key type is not hashable",
+    });
+  }
+
+  let prop_static = vm.static_value(prop);
+  let val = hash_for_twain(prop_static.static_value, vm);
+
+  static_twain.static_value[val] = [prop.__address__, value.__address__];
+
+  vm.write_chain(static_twain, static_twain.__address__);
+
+  vm.air_object(Object.keys(static_twain.static_value).length, options);
+};
+
+const entries = (args, vm, options) => {
+  let { twain } = args;
+
+  if (twain.__classifier__ !== vm.get_type_address("twain")) {
+    return vm.stderr({
+      name: "Type_error",
+      message: "Must be of type `twain`",
+    });
+  }
+
+  let static_twain = vm.static_value(twain);
+  let statics = [], rrays = [];
+
+  for (let s in static_twain.static_value) {
+    let addr = `${twain.__address__}/${s}`;
+    rrays.push(static_twain.static_value[s])
+    statics.push(addr);
+  }
+
+  let local_addresses = statics.map((s) => `${s}_object`);
+
+  local_addresses.map((l, i)=>{
+    vm.air_object(rrays[i], {...options, location:l})
+  })
+  
+  vm.air_object(local_addresses, options)
+};
+
+const keys = (args, vm, options) => {
+  let { twain } = args;
+
+  if (twain.__classifier__ !== vm.get_type_address("twain")) {
+    return vm.stderr({
+      name: "Type_error",
+      message: "Must be of type `twain`",
+    });
+  }
+
+  let static_twain = vm.static_value(twain);
+  let statics = [];
+
+  for (let s in static_twain.static_value) {
+    statics.push(static_twain.static_value[s][0]);
+  }
+
+  vm.air_object(statics, options)
+};
+
+const unset = (args, vm, options) => {
+  let {twain, prop} = args;
+
+  let prop_static = vm.static_value(prop)
+  let twain_static = vm.static_value(twain)
+
+  let hash = hash_for_twain(prop_static.static_value)
+  let has = twain_static.static_value.hasOwnProperty(hash)
+  if (!has){
+    return vm.air_object(null, options)
+  }
+
+  let value = twain_static.static_value[hash]
+
+  let value_obj = vm.read_chain(value[1], {tell_callable:true})
+
+  delete twain_static.static_value[hash]
+
+  vm.write_chain(twain_static, twain_static.__address__)
+
+  vm.write_chain(value_obj.output, options.location, {is_callable: value_obj.callable})
+};
+
+export { get, set, entries, keys, unset };

package/Executables/functions/op.js

@@ -0,0 +1,15 @@
+const operation = (args, vm, options)=>{
+  let {op} = options
+  let {left, right }= args;
+
+  vm.exec({executable: left.__print__, location: (result1)=>{ 
+    if(right){
+      vm.exec({executable: right.__print__, location: (result2)=>{
+        vm.air_object(vm.run_opcode([result1, result2], op), options)
+      }})
+    }else vm.air_object(vm.run_opcode([result1], op), options)
+  }})
+
+}
+
+export default operation

package/Executables/functions/price_register.js

@@ -0,0 +1,30 @@
+import { price } from "./pricing"
+
+const price_register = (account)=>{
+  let add_callable = account.vm.add_callable
+
+  add_callable('price_', {
+    callable: price,
+    config: {
+      parameters: [
+        {name: 'commodity', position:0},
+        {name: 'purpose', position:1},
+        {name: 'fee', position:2},
+      ]
+    }
+  })
+
+  add_callable('pay_', {
+    callable: price,
+    config: {
+      parameters: [
+        {name: 'payer', position:0},
+        {name: 'purpose', position:1},
+        {name: 'fee', position:2},
+        {name: 'payee', position:3},
+      ]
+    }
+  })
+}
+
+export default price_register

package/Executables/functions/pricing.js

@@ -0,0 +1,26 @@
+const price = (args, vm, options)=>{
+  let {commodity, purpose, validator, fee} = args;
+
+  let addr = commodity.__address__
+  let chain = vm.handle_chain(addr)
+  chain.set_fee({purpose, validator, fee})
+
+  return {result: commodity}
+}
+
+const pay = (args, vm, options) =>{
+  let {payer, purpose, fee, payee, callback} = args;
+
+  let chain = vm.handle_chain(payee.__address__)
+  let pass = chain.pay(purpose, fee, payer, (pass)=>{
+    pass = vm.display(pass)
+    if(pass.static_value !== true) return vm.air_object(null, options)
+
+    vm.exec({executable: callback, location: options.location, arguments: {argc:1, argv:[{position:0, static_value: pass.payload}]}})
+  })
+
+  return {result: pass}
+}
+
+
+export {price, pay}

package/Executables/functions/servers/account.js

@@ -0,0 +1,81 @@
+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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,34 @@
+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