godprotocol 1.1.2 → 1.1.31

package/Datatypes/arr.js

@@ -1,10 +1,283 @@
 import Storage from "./functions/storage";
 
 class Arr extends Storage {
-  constructor(value) {
-    super();
+  constructor(payload, manager) {
+    super(payload.config, manager);
 
-    this.value = value;
+    this.instance_object = payload;
+    this.value = payload.value
+    this.type = 'array'
+  }
+
+  call = async (name, args, options={})=>{
+    let {config, chain} = options;
+    let result, other, me =  await this.statics_()
+
+    other = args[0] && await args[0].statics_()
+    
+    let spli = this.value.value.split('/');
+    let config_hash = spli.slice(-1)[0], store;
+
+    switch(name){
+      case 'push':
+        result = me.push( await this.account.vm.instance_address(other))
+        store = true;
+
+        break;
+      case 'length':
+        result = me.length;
+        break;
+      case 'pop':
+        if (other){
+          result = me.splice(other, 1)[0]
+        }else result = me.pop()
+        
+        store= true
+
+        if(result){
+          result = {type:'address',value: result}
+        }
+        break
+      case 'extend':
+        result = me.push(...other)
+        store = true
+        
+        break;
+      case 'slice':
+        let start = args[0] && await args[0].literal()
+        let end = args[1] && await args[1].literal()
+
+        let new_arr = me.slice(start, end)
+        result = new_arr
+        break;
+      case 'splice':
+        let spl_replacement = args[2] && await args[2].statics_()
+        if (spl_replacement){
+          result = me.splice(args[0] && await args[0].literal(), args[1] && await args[1].literal(), await await this.account.vm.instance_address(spl_replacement) )
+        }else result = me.splice(args[0] && await args[0].literal(), args[1] && await args[1].literal())
+        
+        store = true;
+        break;
+      case 'replace':
+        me[await args[0].literal()] = await this.account.vm.instance_address(await args[1].statics_())
+        store = true;
+        break
+      case 'index':
+        let i = args[0] && await args[0].literal()
+        if (i< 0){
+          result = me.slice(i)[0]
+        }else result = me[i]
+        if (result)result = {type:'address', value: result}
+        else result = null
+        break;
+      case 'copy':
+        result = me;
+        break;
+      case 'deepcopy':
+        break;
+      case 'reverse':
+        me = [...me].reverse()
+        result = {type:'address', value: await this.account.vm.instance_address(this.instance_object)}
+
+        if (other){
+          store = true;
+        }else {
+          result = me
+        }
+        break;
+      case "is_empty":
+        result = !me.length
+        break;
+      case 'clear':
+        me = []
+        store = true;
+        break;
+      case 'join':
+        let str_val = ''
+        let separator = (other && await args[0].literal()) || ','
+        for (let i=0; i< me.length; i++){
+          let item = me[i]
+          let val = await this.account.vm.cloth_object(item)
+
+          if (['number', 'string', 'void', 'boolean'].includes(val.type))str_val = `${str_val}${i ? separator: ''}${await val.literal()}`
+        }
+        result = str_val
+        break;
+      case 'repeat':
+        me = Array.from({ length: other? await args[0].literal(): 0 }, () => me).flat()
+        
+        store = true;
+        result = me.length;
+        break;
+      case 'padstart':
+        let p_length = args[0] && await args[0].literal()
+        let value = args[1] && args[1]
+        if (me.length >= p_length){ me = me;
+        }else {
+          let padding = Array(p_length - me.length).fill(['array', 'twain'].includes(value && value.type) ? value.value.address : value.instance_object.address);
+          me = [...padding, ...me];
+          
+          store = true;
+        }
+        result = {type:'address', value: await this.account.vm.instance_address(this.instance_object)}
+
+        break;
+      case 'padend':
+        let ps_length = args[0] && await args[0].literal()
+        let svalue = args[1] && args[1]
+        if (me.length >= ps_length) {me = me;
+        }else {
+          let spadding = Array(ps_length - me.length).fill(['array', 'twain'].includes(svalue && svalue.type) ? svalue.value.address : svalue.instance_object.address);
+          me = [...me, ...spadding];
+          
+          store = true;
+        }
+        result = {type:'address', value: await this.account.vm.instance_address(this.instance_object)}
+        
+        break;
+      case 'to_string':
+        let str = ''
+        if(other){
+          other = await args[0].literal()
+        }
+        for (let a=0; a< me.length; a++){
+          let item = me[a]
+          let val = await this.account.vm.cloth_object(item)
+          if (other === 'ascii'){
+            if (val.type!=='number'){
+              str = `${str}void`
+            }else {
+              val = await val.literal()
+              str = `${str}${String.fromCharCode(val)}`
+            }
+          }
+        }
+        result = str
+        break;
+      case 'map':
+        result = new Array()
+        for (let a=0; a< me.length; a++){
+          let item = me[a]
+          let res = await this.account.vm.execute({
+            type: 'call',
+            arguments: [
+              {type:'address', value: item},
+              {type: 'number', value: a, location: `${config.location}/${await this.account.manager.oracle.hash(a)}`}
+            ],
+            identifier: args[0].value.address,
+            location: config.location,
+          }, {chain})
+
+          result[a] = res.type === 'instance' ? res.address : res.value
+        }
+        break;
+      case 'findindex':
+        for (let a=0; a< me.length; a++){
+          let item = me[a]
+          let res = await this.account.vm.execute({
+            type: 'call',
+            arguments: [
+              {type:'address', value: item},
+              {type: 'number', value: a, location: `${config.location}/${await this.account.manager.oracle.hash(a)}`}
+            ],
+            identifier: args[0].value.address,
+            location: config.location,
+          }, {chain, cloth: true})
+
+          if(await res.literal()){
+            result = a
+            break
+          }
+        }
+        if (result == null)result = -1
+        break;
+      case 'find':
+        for (let a=0; a< me.length; a++){
+          let item = me[a]
+          let res = await this.account.vm.execute({
+            type: 'call',
+            arguments: [
+              {type:'address', value: item},
+              {type: 'number', value: a, location: `${config.location}/${await this.account.manager.oracle.hash(a)}`}
+            ],
+            identifier: args[0].value.address,
+            location: config.location,
+          }, {chain, cloth: true})
+
+          if(await res.literal()){
+            result = {type:'address', value: res. type === 'instance'? res.address: res.value}
+            break
+          }
+        }
+        break;
+      case 'filter':
+        result = []
+        for (let a=0; a< me.length; a++){
+          let item = me[a]
+          let res = await this.account.vm.execute({
+            type: 'call',
+            arguments: [
+              {type:'address', value: item},
+              {type: 'number', value: a, location: `${config.location}/${await this.account.manager.oracle.hash(a)}`}
+            ],
+            identifier: args[0].value.address,
+            location: config.location,
+          }, {chain, cloth: true})
+
+          if(await res.literal()){
+            result.push(item)
+          }
+        }
+        break
+      case 'includes':
+        if(!['number', 'string', 'void', 'boolean'].includes(other.type)) result = false;
+        else {
+          let search = other? await args[0].literal(): null
+          if (!other)result = false;
+          else {
+            for (let a=0; a< me.length; a++){
+              let item = me[a]
+              let obj = await this.account.vm.cloth_object(item)
+    
+              if(['array', 'twain'].includes(obj.type)){
+                result = false
+              }
+              else if(await obj.literal() === search){
+                result = true;
+                break
+              }else result = false
+            }
+          }          
+        }
+        
+    }
+    if(store){
+      await this.account.manager.oracle.write(spli.slice(0,-1).join('/'), {type: this.type, values: me}, {config_hash, config: true})
+    }
+
+    return result
+  }
+
+  configs = (name)=>{
+    let conf = {push: {
+      parameters: [{name: 'item', position: 0}]
+    }}
+
+    return conf[name]
+  }
+
+  push = async({item})=>{
+    if (!item)return null;
+
+    let path = this.config.path;
+    
+    this.value.push(item.to_static())
+
+    this.config.content = this.to_static()
+
+    await this.manager.oracle.fs.write(path, JSON.stringify(this.config))
+    
+    return this.value.length;
   }
 }
 

package/Datatypes/bool.js

@@ -1,10 +1,12 @@
 import Storage from "./functions/storage";
 
 class Bool extends Storage {
-  constructor(value) {
-    super();
+  constructor(payload, account) {
+    super(payload.config, account);
 
-    this.value = value;
+    this.instance_object = payload.value;
+    this.value = JSON.parse(payload.value.value)
+    this.type = 'boolean'
   }
 }
 

package/Datatypes/callable.js

@@ -1,10 +1,11 @@
 import Storage from "./functions/storage";
 
 class Callable extends Storage {
-  constructor(value) {
-    super();
+  constructor(payload, account) {
+    super(payload.config, account);
 
-    this.value = value;
+    this.value = payload.value;
+    this.type = 'callable'
   }
 }
 

package/Datatypes/cls.js

@@ -0,0 +1,41 @@
+import Storage from "./functions/storage";
+
+class Cls extends Storage{
+  constructor(payload, account){
+    super(payload.config, account)
+
+    this.value = payload.value;
+    this.type = 'class'
+  }
+
+  initiate = async({chain, class_chain, ass_chain})=>{
+    let config = this.value
+    let conf = this.config.content;
+    let vm = this.account.vm;
+
+    let obj = {__classifier__: config.identifier, __class_config__: this.config.path}
+
+    let storage_chain = await chain.chain(config.location)
+    let addr = await storage_chain.write(obj)
+
+    class_chain = await storage_chain.chain(config.identifier)
+    let ths = {object: addr, type: 'instance'}
+    await class_chain.write(ths)
+    console.log(obj, config)
+    
+    if (conf.methods.__init__){
+      console.log(conf.methods)
+
+      await vm.execute({
+        type:'call',
+        identifier: `${config.identifier}/__init__`,
+        arguments: config.arguments,
+        object: addr,
+      }, {chain, ass_chain})
+
+    }
+    return ths
+  }
+}
+
+export default Cls

package/Datatypes/conf.js

@@ -0,0 +1,117 @@
+import Arr from "./arr";
+import Storage from "./functions/storage";
+
+class Conf extends Storage{
+  constructor(object, account){
+    super(object, account)
+
+    this.value = object
+    this.type = 'config'
+  }
+
+  persist = async()=>{
+    await this.manager.oracle.fs.write(`${this.value.path}/.config`, JSON.stringify(this.value))
+  }
+
+  set_next = async(addr)=>{
+    this.value.next = addr;
+
+    await this.persist()
+  }
+
+  history = async(query)=>{
+    let res = []
+    let arr, pure;
+    if (typeof query === 'number'){
+      if(query >= 0){}
+      else{
+        arr= []
+        let x=query
+        while (x < 0){
+          arr.push(x)
+          x++
+        }
+      }
+    }
+
+    let i = 0;
+    let age = this.value.age;
+    
+    while(i < arr.length){
+      let timestep = arr[i], my_age;
+      if (timestep < 0){
+        my_age = age + timestep + 1
+      }else {
+        my_age = timestep;
+      }
+      if (my_age > age)continue;
+
+      let config = await this.manager.oracle.fs.get_config(this.value.path, null, {age: my_age})
+
+      res.push(pure?config: await config.read())
+      i++
+    }
+
+    return new Arr({value:res}, this.manager)
+  }
+
+  read = async()=>{
+    let current = this.value.current;
+    if (!current)return
+
+    return await this.manager.oracle.fs.read_file(current)
+  }
+
+  set_previous = async(addr)=>{
+    this.value.previous = addr;
+
+    await this.persist()
+  }
+
+  push = async(parent)=>{
+    this.value.lapse++
+
+    await this.persist()
+  }
+
+  link = async(addr)=>{
+    if (!addr )return;
+    
+    console.log(this.value, addr)
+    if (this.value.current){
+      let conf = await this.manager.oracle.fs.get_config(this.value.current)
+      await conf.set_next(addr)
+
+      let addr_conf = await this.manager.oracle.fs.get_config(`${addr}`)
+
+      await addr_conf.set_previous(this.value.current)
+    }
+
+    this.value.age++
+    this.value.current = addr;
+    await this.persist()
+  }
+}
+
+export default Conf
+
+// test = [1,2,3]
+// ./test
+// ./0 
+//  ./num1 {content:1, previous: null}
+//  ./config {recent: './num1'}
+// ./1
+//  ./num2 {content:2, previous: null}
+//  ./config {recent: './num2'}
+// ./2
+//  ./num3 {content:3, previous:.null}
+//  ./config {recent: './num3'}
+
+// ./.config 
+//    {type:'array', recent: './2'}
+
+// test[1] = 4
+//  ./1
+//    ./num4 {content:4, previous: './num2'}
+//    ./config {recent: './num4'}
+//  

package/Datatypes/func.js

@@ -0,0 +1,22 @@
+import Datatypes from "godprotocol/Objects/Datatypes";
+
+class Func extends Datatypes{
+  constructor(payload, account){
+    super()
+
+    this.account = account
+    this.value = payload;
+    this.type = 'function'
+  }
+
+  literal = ()=>{
+    return `[${this.value.value || this.value.name}]`
+  }
+
+  sync = async()=>{
+    return this
+  }
+}
+
+
+export default Func

package/Datatypes/functions/storage.js

@@ -1,5 +1,24 @@
 class Storage {
-  constructor() {}
+  constructor(manager) {
+    this.manager = manager
+    this.oracle = this.manager.oracle
+  }
+
+  sync = async(manager)=>{
+    if (!this.manager){
+      this.manager = manager
+      this.oracle = this.manager.oracle
+    }
+    return this;
+  }
+
+  persist =async (content, options={})=>{
+    return await this.oracle.write(this.path, content, options)
+  }
+
+  retrieve = async (options)=>{
+    return await this.oracle.read(this.path, options)
+  }
 }
 
 export default Storage;

package/Datatypes/instance.js

@@ -0,0 +1,155 @@
+import Datatypes from "godprotocol/Objects/Datatypes";
+
+class Instance extends Datatypes{
+  constructor(payload, account){
+    super()
+
+    this.account = account
+    this.value = payload;
+    this.type = 'instance'
+  }
+
+  operate = async(op, args, options={})=>{
+    let {classifier} = options;
+    let value;
+    switch(classifier){
+      case 'twain':
+        value = await this.twain(op, args, options)
+        break;
+      case 'number':
+        value = await this.number(op, args)
+        break;
+      case 'array':
+        value = await this.array(op, args, options)
+        break;
+      case 'string':
+        value = await this.string(op, args)
+        break;
+    }
+
+    return value;
+  }
+
+  set = async(last, value)=>{
+    let prop = await last.literal()
+    let oracle = this.account.manager.oracle
+    let hsh = await oracle.hash(prop)
+
+    let {content, path} = this.value
+
+    let prop_path = `${path}/${hsh}`
+    await oracle.fs.mkdir(prop_path)
+    let prop_conf = await oracle.fs.read(`${prop_path}/.config`)
+    if (!prop_conf) prop_conf = {index: -1}
+    
+    if (value.type !== 'address'){
+      value = {type: 'address', value: value.value.path}
+    }
+    await oracle.fs.write(`${prop_path}/${prop_conf.index + 1}`, JSON.stringify([last.value.path, value.value]))
+    prop_conf.index += 1
+    await oracle.fs.write(`${prop_path}/.config`, JSON.stringify(prop_conf))
+    content[hsh] = prop_conf.index
+
+    let path_conf = await oracle.fs.read(`${path}/.config`)
+    
+    let n_hash = await oracle.hash(content)
+    await oracle.fs.write(`${path}/${n_hash}`, JSON.stringify({content, type: 'instance', previous: `${path}/${path_conf.current}`}))
+    path_conf.current = n_hash;
+    await oracle.fs.write(`${path}/.config`, JSON.stringify(path_conf))
+  }
+
+  get = async (prop, options={})=>{
+    let oracle = this.account.manager.oracle
+    let hsh = await oracle.hash(prop)
+    let {config, chain} = options;
+    let {content, path} = this.value, result;
+    
+    let classifier = await oracle.hash('__classifier__')
+    let pair = await oracle.fs.read(`${path}/${classifier}/${content[classifier]}`);
+    let val = await oracle.fs.read(pair[1])
+
+    let is_datatype = this.account.vm.datatypes.includes(val)
+
+    if(Object.keys(content).includes(hsh)){
+      result = await oracle.fs.read(`${path}/${hsh}/${content[hsh]}`)
+      
+      if (result){
+        let res = await oracle.fs.read(result[1])
+        if(!res) result = {type: 'address', value: result[1]}
+        else result = res
+      }
+      
+    }else {
+      if (is_datatype){
+        let res = {
+          type:'address',
+          value: prop,
+          object: path
+        }
+        if(val === 'array' && typeof prop === 'number' && options.obj){
+          result = await this.operate('index', [options.obj], {classifier: val})
+        }else if (val === 'twain'){
+          if (!this.is_literal && options.obj){
+            result = await this.operate('get', [options.obj], {classifier: val})
+            result= await this.account.vm.operate_result(result, config, chain)
+          }else result = res
+        } else result = res
+      }
+
+    }
+    
+    return result;    
+  }
+
+  literal = async ()=>{
+    let oracle = this.account.manager.oracle;
+    if (!this.lit){
+      this.lit = {}
+      let {content, path} = this.value;
+
+      for (let hsh in content){
+        let value = content[hsh];
+
+        let addr = `${path}/${hsh}`;
+        let pair = await oracle.fs.read(`${addr}/${value}`);
+        let prop = await oracle.fs.read(pair[0])
+        let val = await oracle.fs.read(pair[1])
+
+        this.lit[prop] = val
+      }
+    }
+    
+    if (this.lit.__classifier__ === 'twain'){
+      let vm = this.account.vm;
+      if(!this.lit.content_addr) this.lit.content_addr = {...this.lit.content}
+      
+      for (let p in this.lit.content_addr){
+        let [prop, value] = this.lit.content_addr[p]
+        prop = await vm.cloth_content(await vm.resolve_address(prop))
+        value = await vm.cloth_content(await vm.resolve_address(value))
+        
+        delete this.lit.content[p] 
+        this.lit.content[await prop.literal()] = await value.literal()
+      }
+    }else if (this.lit.__classifier__ === 'array'){
+      let vm = this.account.vm;
+      
+      if(!this.lit.content_addr)
+      this.lit.content_addr = [...this.lit.content]
+      for (let i=0; i< this.lit.content_addr.length; i++){
+        let item = this.lit.content_addr[i]
+        item = await vm.cloth_content(await vm.resolve_address(item))
+        
+        this.lit.content[i] = await item.literal()
+      }
+
+    }
+    return this.lit.content;
+  }
+
+  sync = async()=>{
+    return this;
+  }
+}
+
+export default Instance