godprotocol 1.1.0 → 1.1.2

package/Executables/functions/methods/array.js

@@ -1,272 +0,0 @@
-import typecast from "../typecast";
-
-const insert = (args, vm, options) => {
-  let { arr, index, value } = args;
-
-  if (
-    !index ||
-    (index && index.__classifier__ !== vm.get_type_address("number"))
-  )
-    index = { static_value: undefined };
-  else index = vm.static_value(index);
-
-  vm.exec({
-    executable: arr.__print__,
-    location: (result) => {
-      if (index.static_value != undefined) {
-        result.static_value.splice(index.static_value, 0, value.__address__);
-      } else result.static_value = [...result.static_value, value.__address__];
-
-      vm.write_chain(result, result.__address__);
-
-      vm.air_object(result.static_value.length, options);
-    },
-  });
-};
-
-const pop = (args, vm, options) => {
-  let { arr, index } = args;
-
-  if (
-    !index ||
-    (index && index.__classifier__ !== vm.get_type_address("number"))
-  )
-    index = { static_value: undefined };
-  else index = vm.static_value(index);
-
-  vm.exec({
-    executable: arr.__print__,
-    location: (result) => {
-      let item;
-      if (
-        index.static_value != undefined ||
-        index.static_value >= result.static_value.length
-      ) {
-        item = result.static_value.splice(index.static_value, 1);
-        item = item[0];
-      } else item = result.static_value.pop();
-
-      vm.write_chain(result, result.__address__);
-
-      vm.write_chain(vm.read_chain(item), options.location);
-    },
-  });
-};
-
-const repeat = (args, vm, options) => {
-  let {arr, n} = args;
-
-  if (
-    !n ||
-    (n && n.__classifier__ !== vm.get_type_address("number"))
-  )
-    n = { static_value: 0 };
-  else n = vm.static_value(n);
-
-  vm.exec({executable: arr.__print__, location: result=>{
-    let og = result.static_value;
-    let sv = [...result.static_value];
-    
-    for (let i=0; i< n.static_value; i++){
-      sv.push(...og)
-    }
-    vm.write_chain({...result, static_value: sv}, result.__address__)
-    vm.write_chain(arr, options.location)
-  }})
-};
-
-const concat_ = (arr, other, index) => {
-  if (index === undefined || index > arr.length) {
-    index = arr.length;
-  }
-
-  let start = arr.slice(0, index);
-  let end = arr.slice(index);
-
-  arr = [...start, ...other, ...end];
-
-  return arr;
-};
-
-const concat = (args, vm, options) => {
-  let { spread } = options;
-  let { arr, other, index } = args;
-
-  if (other.__classifier__ !== vm.get_type_address("array")) {
-    other = typecast({
-      obj: vm.static_value(other),
-      typ: { static_value: "array" },
-    });
-  } else other = vm.static_value(other);
-  if (
-    !index ||
-    (index && index.__classifier__ !== vm.get_type_address("number"))
-  )
-    index = { static_value: undefined };
-  else index = vm.static_value(index);
-
-  vm.exec({
-    executable: arr.__print__,
-    location: (result) => {
-      let res = concat_(
-        result.static_value,
-        spread ? other.static_value : [other.static_value],
-        index.static_value
-      );
-      vm.write_chain({ ...result, static_value: res }, result.__address__);
-
-      vm.write_chain(arr, options.location);
-    },
-  });
-};
-
-const index = (args, vm, options) => {
-  let { arr, n } = args;
-
-  if (!n || (n && n.__classifier__ !== vm.get_type_address("number")))
-    return vm.air_object(null, options);
-  else n = vm.static_value(n);
-
-  vm.exec({
-    executable: arr.__print__,
-    location: (result) => {
-      if (n.static_value < 0 ||( n.static_value >= result.static_value.length))
-        return vm.air_object(null, options);
-
-      vm.write_chain(vm.read_chain(result.static_value[n.static_value]), options.location);
-    },
-  });
-};
-
-const slice = (args, vm, options) => {
-  let { arr, start, end } = args;
-
-  if (start.__classifier__ !== vm.get_type_address("number")) {
-    return { result: arr };
-  } 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: arr.__print__,
-    location: (result) => {
-      let new_val = result.static_value.slice(
-        start.static_value,
-        end.static_value
-      );
-
-      vm.air_object(new_val, options);
-    },
-  });
-};
-
-const clear = (args, vm) => {
-  let { arr } = args;
-
-  vm.exec({
-    executable: arr.__print__,
-    location: (result) => {
-      result.static_value = [];
-      vm.write_chain(result, result.__address__);
-
-      vm.write_chain(arr, options.location);
-    },
-  });
-};
-
-const replace = (args, vm) => {
-  let { arr, index, value } = args;
-
-  if (
-    !index ||
-    (index && index.__classifier__ !== vm.get_type_address("number"))
-  )
-    return { result: arr };
-  else index = vm.static_value(index);
-
-  vm.exec({
-    executable: arr.__print__,
-    location: (result) => {
-      result.static_value.splice(index.static_value, 1, value.__address__);
-
-      vm.write_chain(result, result.__address__);
-
-      vm.write_chain(arr, options.location);
-    },
-  });
-};
-
-const find = (args, vm, options)=>{
-  let {index} = options;
-  let {arr, executable} = args;
-
-  // console.log(args, 'find.args')
-
-  vm.exec({executable: arr.__print__, location: result=>{
-    let stv = result.static_value;
-    
-    vm.exec({executable, metadata: {loop:{index:0, array: stv, conditioner: res=>{
-      res = vm.static_value(res)
-      return (res && res.static_value === true)
-    }}}, arguments:{argv:[{address: stv[0], position: 0}], argc:1}, location: (result, metadata)=>{
-      result = vm.static_value(result)
-      if(result.static_value=== true){
-        if (index){
-          vm.air_object(metadata.loop.index, options)
-        }else vm.write_chain(this.read_chain(stv[metadata.loop.index]), options.location)
-      }else {
-        vm.air_object(index? -1: null, options)
-      }
-    }})
-  }})
-}
-
-const filter = (args, vm, options)=>{
-  let {arr, executable} = args;
-
-  // console.log(args, 'filter.args')
-
-  vm.exec({executable: arr.__print__, location: result=>{
-    let stv = result.static_value;
-    let filts = []
-    
-    vm.exec({executable, metadata: {loop:{index:0, array: stv, conditioner: reslt=>{
-      let res = vm.static_value(reslt)
-      if (res && res.static_value === true){
-        filts.push(reslt)
-      }
-      return true
-    }}}, arguments:{argv:[{address: stv[0], position: 0}], argc:1}, location: (result, metadata)=>{
-      vm.air_object(filts, {...options, item_type:'static_object'})
-    }})
-  }})
-}
-
-const map = (args, vm, options)=>{
-  let {arr, executable} = args;
-
-  // console.log(args, 'map.args')
-
-  vm.exec({executable: arr.__print__, location: result=>{
-    let stv = result.static_value;
-    let mapped_values = []
-    
-    vm.exec({executable, metadata: {loop:{index:0, array: stv, conditioner: (res, metadata)=>{
-      mapped_values.push(res)
-      return metadata.loop.index+1 === stv.length
-    }}}, arguments:{argv:[{address: stv[0], position: 0}], argc:1}, location: (result)=>{
-
-      vm.air_object(mapped_values, {...options, item_type:'static_object'})
-
-    }})
-    
-  }})
-}
-
-const copy = (args, vm, options)=>{
-  let {arr, depth} = args;
-}
-
-export { pop, insert, repeat, map, concat, index, find, clear, slice, replace , filter, copy};

package/Executables/functions/methods/string.js

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

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

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

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

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