godprotocol 1.1.2 → 1.1.3

package/Objects/Datatypes.js

@@ -0,0 +1,620 @@
+class Datatypes{
+
+  string = async(op, args)=>{
+    let me = await this.literal(),
+    other = args[0], result=null;
+
+    console.log(op)
+    switch(op){
+      case 'upper':
+        result = me.toUpperCase()
+        break;
+      case 'lower':
+        result = me.toLowerCase()
+        break;
+      case 'title':
+        result = "";
+        me = me.split(' ').map(m=>{
+          result = `${result} ${m[0].toUpperCase()}${m.slice(1).toLowerCase()}`.trim()
+        })
+        break;
+      case 'slice':
+        let start = args[0], end = args[1];
+        start = start && await start.literal()
+        end = end && await end.literal()
+
+        result = me.slice(start, end)
+        break;
+      case 'concat':
+        other = await args[0].literal()
+        result = `${me}${other}`
+        break;
+      case 'find':
+        let lst = args[1] && await args[1].literal()
+        result = me[lst?'lastIndexOf': 'indexOf'](await other.literal())
+        break;
+      case 'includes':
+        result = me.includes(await other.literal())
+        break;
+      case 'index':
+        other = await other.literal()
+        if (other < 0){
+          result = me.slice(other)[0]
+        }else result = me[other]
+        break;
+      case 'trim':
+        other = args[0]
+        if (other) other = await other.literal()
+        else other = 0
+        let char = args[1]
+        if (char) char = await char.literal()
+        else char = ' '
+
+        let esc_regx_char = (char) => char.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+        let char_regx = esc_regx_char(char);
+
+        switch (other) {
+          case 1:
+            result = me.replace(new RegExp(`^${char_regx}+`), '');
+            break
+          case 2:
+            result = me.replace(new RegExp(`${char_regx}+$`), '');
+            break
+          case 0:
+          default:
+            result = me.replace(new RegExp(`^${char_regx}+|${char_regx}+$`, 'g'), '');
+        }
+        break;
+      case 'length':
+        result = me.length;
+        break;
+      case 'is_empty':
+        result = !!me
+        break;
+      case 'is_blank':
+        result = !!me.trim()
+        break;
+      case 'is_numeric':
+        result = !!me && !isNaN(Number(me))
+        break;
+      case "endswith":
+        result = me.endsWith(await other.literal())
+        break;
+      case "startswith":
+        result = me.startsWith(await other.literal())
+        break;
+      case 'padend':
+        result = me.padEnd(await other.literal(), await args[1].literal())
+        break;
+      case 'padstart':
+        result = me.padStart(await other.literal(), await args[1].literal())
+        break;
+      case 'count':
+        other = await args[0].literal()
+
+        let count = 0;
+        let position = 0;
+
+        while ((position = me.indexOf(other, position)) !== -1) {
+          count++;
+          position += other.length;
+        }
+        result = count;
+        break;
+      case 'reverse':
+        result = me.split('').reverse().join('');
+        break
+      case 'repeat':
+        result = me.repeat(await other.literal())
+        break
+      case 'replace':
+        let globally = args[2] && await args[2].literal(),
+        keyword = await other.literal(), replacement = await args[1].literal()
+        result = me.replace(keyword, replacement)
+        if (globally){
+          while(result.includes(keyword)) result = result.replace(keyword, replacement)
+        }
+        break
+      case 'split':
+        other = other ? await other.literal(): ' '
+        result = me.split(other)
+        break
+      case 'charcode':
+        let code = args[1] ? await args[1].literal() : 'ascii'
+        if (code === 'ascii'){
+          result = me.split("").map(char => char.charCodeAt(0))
+        }
+        
+        break;
+    }
+
+    return result
+  }
+
+  number = async (op, args)=>{
+    let other = args[0]
+
+    other = other && await other.literal()
+    let me = await this.literal()
+    
+    let result;
+    switch(op){
+      case '__add__':
+        result = me + other;
+        break;
+      case '__sub__':
+        result = me - other;
+        break;
+      case '__mul__':
+        result = me * other;
+        break;
+      case '__div__':
+        if (!other)result = { error:true, value:{name: 'ZeroDivision'}}
+        else result = me / other;
+        break;
+      case '__exp__':
+        result = me ** other;
+        break;
+      case '__floordiv__':
+        result = Math.floor(me / other);
+        break;
+      case '__mod__':
+        result = me % other;
+        break;
+      case '__eq__':
+        result = me === other
+        break;
+      case '__ne__':
+        result = me !== other
+        break;
+      case '__lt__':
+        result = me < other
+        break;
+      case '__lte__':
+        result = me <= other
+        break;
+      case '__gt__':
+        result = me > other
+        break;
+      case '__gte__':
+        result = me >= other
+        break;
+      case 'abs':
+        result = Math.abs(me)
+        break;
+      case 'sqrt':
+        result = Math.sqrt(me)
+        break;
+      case 'to_int':
+        result = parseInt(me)
+        break;
+      case 'to_float':
+        result = Number(me).toFixed(other)
+        break;
+      case 'to_string':
+        result = me.toString()
+        break;
+      case 'tan':
+        result = Math.tan(me)
+        break;
+      case 'sin':
+        result = Math.sin(me)
+        break;
+      case 'cos':
+        result = Math.cos(me)
+        break;
+      case 'atan':
+        result = Math.atan(me)
+        break;
+      case 'atan2':
+        result = Math.atan2(me)
+        break;
+      case 'asin':
+        result = Math.asin(me)
+        break;
+      case 'acos':
+        result = Math.acos(me)
+        break;
+      case 'tanh':
+        result = Math.tanh(me)
+        break;
+      case 'sinh':
+        result = Math.sinh(me)
+        break;
+      case 'cosh':
+        result = Math.cosh(me)
+        break;
+      case 'asinh':
+        result = Math.asinh(me)
+        break;
+      case 'acosh':
+        result = Math.acosh(me)
+        break;
+      case 'atanh':
+        result = Math.atanh(me)
+        break;
+      case 'round':
+        if (other){
+          result = Number(Number(me).toFixed(other))
+        }else result = Math.round(me)
+        break;
+      case 'ceil':
+        result = Math.ceil(me)
+        break;
+      case 'floor':
+        result = Math.floor(me)
+        break;
+      case 'is_prime':
+        if (me <= 1) result = false;
+        if (me <= 3) result = true;
+        
+        if (me % 2 === 0 || me % 3 === 0) result = false; 
+        
+        for (let i = 5; i * i <= me; i += 6) {
+          if (me % i === 0 || me % (i + 2) === 0) {
+            result = false;
+          }
+        }
+        result = true;
+        break;
+      case 'is_odd':
+        result = (me % 2) === 1
+        break
+      case 'is_even':
+        result = (me % 2) === 0
+        break
+      case 'log':
+        if (!other || (other === 10))
+          result = Math.log10(me)
+        else if (other === Math.E){
+          result = Math.log(me)
+        }else result = Math.log(me) / Math.log(other)
+        break;
+      case 'factorial':
+        result = this.factorial(me)
+        break;
+      case 'is_perfect_square':
+        if (me < 0) result = false; 
+        
+        let sqrt = Math.sqrt(me);
+        result = sqrt === Math.floor(sqrt);
+        break
+      case 'to_degrees':
+        result = me * (180 / Math.PI)
+        break;
+      case 'to_radians':
+        result = me * (Math.PI / 180)
+        break;
+    }
+
+    return result    
+  }
+
+  array = async(op, args, options={})=>{
+    let {config, chain } = options;
+    
+    await this.literal()
+    let other = args[0], store, result = null;
+
+    switch(op){
+      case 'push':
+        result = this.lit.content_addr.push(other.value.path)
+        store = true;
+        break;
+      case 'length':
+        result = this.lit.content.length;
+        break;
+      case 'pop':
+        if (other){
+          result = this.lit.content_addr.splice(await other.literal(), 1)[0]
+        }else result = this.lit.content_addr.pop()
+        
+        store= true
+
+        if(result){
+          result = {type:'address',value: result}
+        }
+        break;
+      case 'extend':
+        await other.literal()
+        result = this.lit.content_addr.push(...other.lit.content_addr)
+        store = true
+        
+        break;
+      case 'slice':
+        let start = args[0] && await args[0].literal()
+        let end = args[1] && await args[1].literal()
+
+        let new_arr = this.lit.content_addr.slice(start, end)
+        result = new_arr
+
+        let res = await this.account.vm.instantiate({type:'array', value: result, location: config.location}, {chain, pure: true})
+
+        result = {type:'address', value: res}
+        break;
+      case 'splice':
+        let spl_replacement = args[2]
+        if (spl_replacement){
+          result = this.lit.content_addr.splice(args[0] && await args[0].literal(), args[1] && await args[1].literal(), spl_replacement.value.path )
+        }else result = this.lit.content_addr.splice(args[0] && await args[0].literal(), args[1] && await args[1].literal())
+        
+        store = true;
+
+        result = {type:'address', value: await this.account.vm.instantiate({type:'array', value: result, location: config.location}, {chain, pure: true})}
+
+        break;
+      case 'index':
+        other = await other.literal()
+        if (typeof other === 'number'){
+          if (other <0){
+            result = this.lit.content_addr.slice(other)[0]
+          }else result = this.lit.content_addr[other];
+        }
+        if (result) result = {type:'address', value: result}
+        break;
+      case 'to_string':
+        other = other && await other.literal()
+
+        result = ''
+        for (let i=0; i< this.lit.content_addr.length; i++){
+          let item = this.lit.content_addr[i];
+
+          let cont = await this.account.vm.resolve_address(item);
+          cont = await this.account.vm.cloth_content(cont)
+          cont = await cont.literal()
+          if (other === 'ascii'){
+            if (typeof cont === 'number'){
+              result = `${result}${String.fromCharCode(cont)}`
+            }else result = `${result}void`
+          }else result = `${result}${cont}`
+        }
+        break;
+      case 'is_empty':
+        result = !this.lit.content_addr.length
+        break;
+      case 'clear':
+        this.lit.content_addr = []
+        store = true;
+        break
+      case "join":
+        let str_val = ''
+        let separator = (other && await other.literal()) || ','
+        for (let i=0; i< this.lit.content_addr.length; i++){
+          let item = this.lit.content_addr[i]
+          let val = await this.account.vm.cloth_content(await this.account.vm.resolve_address(item))
+
+          let cont = await val.literal()
+          if (['number', 'string', 'void', 'boolean'].includes(typeof cont))str_val = `${str_val}${i ? separator: ''}${cont}`
+        }
+        result = str_val
+        break;
+      case 'map':
+        let confg = other.value;
+        let map_arr = []
+        for (let i=0; i< this.lit.content_addr.length; i++){
+          let item = this.lit.content_addr[i];
+          
+          let res = await this.account.vm.execute(confg, {call_config: {
+            identifier: confg.address,
+            arguments: [
+              {type:'address', value: item, position: 0},
+              {...await this.account.vm.parse_aircode(i, {config, chain}), position:1}
+            ],
+            location: config.location
+          }, chain})
+          if (res && res.type!== 'address'){
+            console.log("Datatypes.js:Query")
+          }
+          map_arr.push(res.value)
+        }
+        if (args[1] && await args[1].literal()){
+          this.lit.content_addr = map_arr
+          store = true
+        }else result = {type:'address', value: await this.account.vm.instantiate({type:'array', value: map_arr, location: config.location}, {chain, pure: true})}
+        
+        break;
+      case 'filter':
+        let fconfg = other.value;
+        let fil_arr = []
+        for (let i=0; i< this.lit.content_addr.length; i++){
+          let item = this.lit.content_addr[i];
+          
+          let res = await this.account.vm.execute(fconfg, {call_config: {
+            identifier: fconfg.address,
+            arguments: [
+              {type:'address', value: item, position: 0},
+              {...await this.account.vm.parse_aircode(i, {config, chain}), position:1}
+            ],
+            location: config.location
+          }, chain, cloth: true})
+          
+          if (res && !!await res.literal())
+            fil_arr.push(item)
+        }
+        if (args[1] && await args[1].literal()){
+          this.lit.content_addr = fil_arr
+          store = true
+        }else result = {
+          type:'address', 
+          value: await this.account.vm.instantiate({
+            type:'array', 
+            value: fil_arr, 
+            location: config.location}, 
+            {chain, pure: true})
+        }
+        
+        break;
+      case 'find':
+        let fnconfg = other.value;
+        for (let i=0; i< this.lit.content_addr.length; i++){
+          let item = this.lit.content_addr[i];
+          
+          let index = await this.account.vm.parse_aircode(i, {config, chain})
+          let res = await this.account.vm.execute(fnconfg, {call_config: {
+            identifier: fnconfg.address,
+            arguments: [
+              {type:'address', value: item, position: 0},
+              {...index, position:1}
+            ],
+            location: config.location
+          }, chain, cloth: true})
+          
+          if (res && !!await res.literal())
+            {
+            result = index
+            break
+            }
+        }
+      case 'includes':
+        other = await other.literal()
+        for (let i=0; i< this.lit.content_addr.length; i++){
+          let item = this.lit.content_addr[i];
+          let val = await this.account.vm.cloth_content(await this.account.vm.resolve_address(item))
+
+          if (await val.literal() === other){
+            result = true;
+            break
+          }
+        }
+        result = result || false
+        break;
+      case 'copy':
+        result = {
+          type:'address', 
+          value: await this.account.vm.instantiate({
+            type:'array', 
+            value: [...this.lit.content_addr], 
+            location: config.location}, 
+            {chain, pure: true})
+        }
+        break;
+      case 'reverse':
+        this.lit.content_addr.reverse()
+        store = true
+        break;
+    }
+
+    if (store) {
+      let oracle = this.account.manager.oracle
+      let obj = {content: JSON.stringify(this.lit.content_addr), __classifier__: 'array', uid: this.lit.uid}
+      
+      let path_split = this.value.path.split('/')
+      await oracle.fs.store(obj, {path: path_split.slice(0,-1).join('/'), hash: path_split[path_split.length-1], is_instance: true, type: 'twain'})
+    }
+
+    return result
+  }
+
+  twain = async(op, args, options)=>{
+    let {config, chain} = options
+    await this.literal()
+
+    let result = null, store, other = args[0];
+    switch(op){
+      case 'entries':
+        result = []
+        for (let p in this.lit.content_addr){
+          let pair = this.lit.content_addr[p]
+
+          result.push(await this.account.vm.instantiate({
+            type:'array', 
+            value: pair, 
+            location: config.location}, 
+            {chain, pure: true}))
+        }
+        result = {type:'address', value: await this.account.vm.instantiate({
+          type:'array', 
+          value: result, 
+          location: config.location}, 
+          {chain, pure: true})
+        }
+        break;
+      case 'keys':
+        result = []
+        for (let p in this.lit.content_addr){
+          let pair = this.lit.content_addr[p]
+
+          result.push(pair[0])
+        }
+        result = {type:'address', value: await this.account.vm.instantiate({
+          type:'array', 
+          value: result, 
+          location: config.location}, 
+          {chain, pure: true})
+        }
+        break;
+
+      case 'values':
+        result = []
+        for (let p in this.lit.content_addr){
+          let pair = this.lit.content_addr[p]
+
+          result.push(pair[1])
+        }
+        result = {type:'address', value: await this.account.vm.instantiate({
+          type:'array', 
+          value: result, 
+          location: config.location}, 
+          {chain, pure: true})
+        }
+        break;
+      case 'get':
+        if(typeof other === 'string'){}
+        else other = other && await other.literal()
+
+        let hash = await this.account.manager.oracle.hash(other, 'sha1')
+        let val = this.lit.content_addr[hash]
+        if (val)result = {type: 'address', value: val[1]}
+        break;
+      case 'set':
+        other = other && await other.literal()
+        let shash = await this.account.manager.oracle.hash(other, 'sha1')
+        
+        this.lit.content_addr[shash] = [args[0].value.path, args[1].value.path]
+        store = true;
+        break;
+      case 'remove':
+        other = other && await other.literal()
+        let rhash = await this.account.manager.oracle.hash(other, 'sha1')
+        let rval = this.lit.content_addr[rhash]
+        if(rval)result = true
+        else result = false;
+        
+        delete this.lit.content_addr[rhash]
+        store = true;
+        break
+      case 'copy':
+        result = {type:'address', value: await this.account.vm.instantiate({
+          type:'twain', 
+          value: this.lit.content_addr, 
+          location: config.location}, 
+          {chain, pure: true})
+        }
+        break;
+      case 'clear':
+        this.lit.content_addr = {}
+        store = true;
+        break
+
+    }
+
+    if (store) {
+      let oracle = this.account.manager.oracle
+      let obj = {content: JSON.stringify(this.lit.content_addr), __classifier__: 'twain', uid: this.lit.uid}
+      
+      let path_split = this.value.path.split('/')
+      await oracle.fs.store(obj, {path: path_split.slice(0,-1).join('/'), hash: path_split[path_split.length-1], is_instance: true, type: 'twain'})
+    }
+
+    return result
+  }
+
+  factorial = (value)=>{
+    if (value === 0)
+      return 1
+    return value * this.factorial(value - 1)
+  }
+}
+
+export default Datatypes;

package/Objects/Manager.js

@@ -1,8 +1,8 @@
 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 Blockweb from "./Blockweb";
 import Repository from "./Repository";
 
 class Manager {
@@ -10,6 +10,7 @@ class Manager {
     this.name = name;
     this.options = options || {};
 
+    this.trinity = options.trinity;
     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}`;
@@ -17,8 +18,8 @@ class Manager {
     this.server = options.server;
     this.accounts = new Object();
 
-    this.oracle = new Oracle(this);
     this.web = new Blockweb(this);
+    this.oracle = new Oracle(this);
 
     this.repository = new Repository(this);
   }
@@ -32,6 +33,7 @@ class Manager {
 
     this.post_request = post_request;
 
+    await this.oracle.sync()
     await this.repository.sync(this.name);
   };
 
@@ -44,7 +46,13 @@ class Manager {
     await account.sync();
 
     this.accounts[name] = account;
+
+    return account;
   };
+
+  get_account = name=>{
+    return this.accounts[name]
+  }
 }
 
 export default Manager;