godprotocol 1.1.32 → 1.2.0

package/Datatypes/functions/storage.js

@@ -1,23 +1,583 @@
+import { generate_random_string } from "generalised-datastore/utils/functions.js";
+
 class Storage {
-  constructor(manager) {
-    this.manager = manager
-    this.oracle = this.manager.oracle
+  constructor(account) {
+    this.account = account
+
+    this.methods = {
+      'get_id': {args:[], ret: ['_id', 'string']},
+      'folder': {args:[['address', 'string'], ['options', 'twain']], ret: ['folder', 'folder']},
+
+      '__and__': {args: [['other', 'object']], ret: ['result', 'object']},
+      '__sub__': {args: [['other', 'object']], ret: ['result', 'object']},
+      '__or__': {args: [['other', 'object']], ret: ['result', 'object']},
+      '__add__': {args: [['other', 'object']], ret: ['result', 'object']},
+      '__mul__': {args: [['other', 'object']], ret: ['result', 'object']},
+      '__div__': {args: [['other', 'object']], ret: ['result', 'object']},
+      '__gt__': {args: [['other', 'object']], ret: ['result', 'object']},
+      '__lt__': {args: [['other', 'object']], ret: ['result', 'object']},
+      '__gte__': {args: [['other', 'object']], ret: ['result', 'object']},
+      '__lte__': {args: [['other', 'object']], ret: ['result', 'object']},
+      '__ne__': {args: [['other', 'object']], ret: ['result', 'object']},
+      '__eq__': {args: [['other', 'object']], ret: ['result', 'object']},
+    }
+  }
+
+  __or__ = async(other)=>{
+    let result;
+    switch(this.type){
+      case 'number':
+        if (typeof other === 'number')
+          result = this.value || other
+        break
+      case 'string':
+        result = this.value || other
+        break
+      case 'void':
+        result = await other.to_address()
+        break
+      case 'function':
+        result = await this.to_address()
+        break
+      case 'instance':
+        result = await this.run('__or__', {config: {arguments: [other], location: this.spawn_address()}, chain: this.account.chain})
+        break;
+    }
+    if (!result) result = await this.account.vm.voided()
+
+    return result
+  }
+
+  __and__ = async(other)=>{
+    let result;
+
+    switch(this.type){
+      case 'number':
+        if (typeof other === 'number')
+          result = this.value && other
+        break
+      case 'instance':
+        result = await this.run('__and__', {config: {arguments: [other], location: this.spawn_address()}, chain: this.account.chain})
+        break;
+    }
+    if (!result) result = await this.account.vm.voided()
+
+    return result
+  }
+
+  __gt__ = async(other)=>{
+    let result;
+
+    switch(this.type){
+      case 'number':
+        if (typeof other === 'number')
+          result = this.value > other
+        break
+      case 'instance':
+        result = await this.run('__gt__', {config: {arguments: [other], location: this.spawn_address()}, chain: this.account.chain})
+        break;
+    }
+    if (!result) result = await this.account.vm.voided()
+
+    return result
+  }
+
+  __gte__ = async(other)=>{
+    let result;
+
+    switch(this.type){
+      case 'number':
+        if (typeof other === 'number')
+          result = this.value >= other
+        break
+      case 'instance':
+        result = await this.run('__gte__', {config: {arguments: [other], location: this.spawn_address()}, chain: this.account.chain})
+        break;
+    }
+    if (!result) result = await this.account.vm.voided()
+
+    return result
+  }
+
+  __lt__ = async(other)=>{
+    let result;
+
+    switch(this.type){
+      case 'number':
+        if (typeof other === 'number')
+          result = this.value < other
+        break
+      case 'instance':
+        result = await this.run('__lt__', {config: {arguments: [other], location: this.spawn_address()}, chain: this.account.chain})
+        break;
+    }
+    if (!result) result = await this.account.vm.voided()
+
+    return result
+  }
+
+  __lte__ = async(other)=>{
+    let result;
+
+    switch(this.type){
+      case 'number':
+        if (typeof other === 'number')
+          result = this.value <= other
+        break
+      case 'instance':
+        result = await this.run('__lte__', {config: {arguments: [other], location: this.spawn_address()}, chain: this.account.chain})
+        break;
+    }
+    if (!result) result = await this.account.vm.voided()
+
+    return result
+  }
+
+  __eq__ = async(other)=>{
+    let result;
+
+    switch(this.type){
+      case 'number':
+        if (typeof other === 'number')
+          result = this.value == other
+        break
+      case 'string':
+        result = this.value == other
+        break
+      case 'class':
+        result = this.ref() === other.ref()
+        break
+      case 'function':
+        result = this.ref() === other.ref()
+        break
+      case 'instance':
+        await this.run('__eq__', {config: {arguments: [other], location: this.spawn_address()}, chain: this.account.chain})
+        break;
+    }
+    if (result == null) result = await this.account.vm.voided()
+
+    return result
+  }
+
+  __ne__ = async(other)=>{
+    let result;
+
+    switch(this.type){
+      case 'number':
+        if (typeof other === 'number')
+          result = this.value != other
+        break
+      case 'void':
+        result = other.type === 'void'
+        break
+      case 'class':
+        result = this.ref() !== other.ref()
+        break
+      case 'function':
+        result = this.ref() !== other.ref()
+        break
+      case 'instance':
+        result = await this.run('__ne__', {config: {arguments: [other], location: this.spawn_address()}, chain: this.account.chain})
+        break;
+    }
+    if (result==null) result = await this.account.vm.voided()
+
+    return result
+  }
+
+  __div__ = async(other)=>{
+    let result;
+
+    switch(this.type){
+      case 'number':
+        if (typeof other === 'number')
+          result = this.value / other
+        break
+      case 'instance':
+        result = await this.run('__div__', {config: {arguments: [other], location: this.spawn_address()}, chain: this.account.chain})
+        break;
+    }
+    if (!result) result = await this.account.vm.voided()
+
+    return result
   }
 
-  sync = async(manager)=>{
-    if (!this.manager){
-      this.manager = manager
-      this.oracle = this.manager.oracle
+  __mul__ = async(other)=>{
+    let result;
+
+    switch(this.type){
+      case 'number':
+        if (typeof other === 'number')
+          result = this.value * other
+        break
+      case 'string':
+        if (typeof other === 'string')
+          result = await this.repeat(other)
+        break;
+      case 'instance':
+        result = await this.run('__mul__', {config: {arguments: [other], location: this.spawn_address()}, chain: this.account.chain})
+        break;
+    }
+    if (!result) result = await this.account.vm.voided()
+
+    return result
+  }
+
+  __sub__ = async(other)=>{
+    let result;
+
+    switch(this.type){
+      case 'number':
+        if (typeof other === 'number')
+          result = this.value - other
+        break
+      case 'instance':
+        result = await this.run('__sub__', {config: {arguments: [other], location: this.spawn_address()}, chain: this.account.chain})
+        break;
+    }
+    if (!result) result = await this.account.vm.voided()
+
+    return result
+  }  
+  
+  __add__ = async(other)=>{
+    let result;
+
+    switch(this.type){
+      case 'number':
+        if (typeof other === 'number')
+          result = this.value + other
+        break
+      case 'string':
+        if (typeof other === 'string')
+          result = await this.concat(other)
+        break;
+      case 'instance':
+        result = await this.run('__add__', {config: {arguments: [other], location: this.spawn_address()}, chain: this.account.chain})
+        break;
     }
-    return this;
+    if (!result) result = await this.account.vm.voided()
+
+    return result
+  }
+
+  _folder = async(options={})=>{
+    let addr = this.type === 'folder'? this.config.value: this.address
+    let folder = await this.account.manager.ds.folder(addr, {...options})
+
+    return folder;
   }
 
-  persist =async (content, options={})=>{
-    return await this.oracle.write(this.path, content, options)
+  emit = async(name, args)=>{
+    name = await name.literal()
+    if(this.type === 'instance'){
+      name = `${name}:${this.config._id}`
+    }
+    
+    let fold = await this._folder()
+    let res = await fold.emit(name, args[1]? [await args[1].to_address()]: [], {account: this.account})
+    let {vm, chain} = this.account
+
+    return await vm.instantiate({
+      type: 'array',
+      value: res,
+      location: vm.gen_location()
+    }, {chain})
+  }
+
+  listen = async(name, args)=>{
+    name = await name.literal()
+    let func = await args[1].to_address()
+
+    if (this.type === 'instance'){
+      name = `${name}:${this.config._id}`
+    }
+
+    let fold = await this._folder()
+    await fold.listen(name, func, {account: this.account})
+  }
+
+  folder = async(address, args, {call_config, chain})=>{
+    let parent = this.config.location
+    if (this.type === 'instance'){
+      parent = `${this.config.cls}/${this.config._id}`
+    }
+    let fold = await this.account.manager.ds.folder(parent, {account: this.account.physical_address})
+    address = await address.literal()
+
+    let subfolder = await fold.folder(address, {account: this.account.physical_address})
+
+    let obj = {
+      type: 'folder',
+      value: subfolder.address,
+      location: call_config.location
+    }
+
+    let folder = await chain.folder(call_config.location)
+    let res = await folder.write(obj)
+
+    return {
+      type: 'address',
+      value: folder.address,
+      _id: res._id
+    }
+  }
+
+  get_id = async()=>{
+    return this.config._id
+  }
+
+  call = async(method, options)=>{
+    let {chain, call_config, pure, thread} = options
+    let {arguments: args} = call_config, other, result;
+    let method_name = method;
+
+    let args_ = new Array()
+    for(let a=0; a < args.length; a++){
+      args_[a] = await this.account.vm.cloth(args[a])
+    }
+    args = args_
+    switch(this.type){
+      case 'number':
+        this.value = await this.literal()
+        other = args[0] && await args[0].literal()
+        method = this[method]
+        if (typeof method === 'function'){
+          result = await method(other, args, {call_config, thread, chain})
+        }
+        break;
+      case 'string':
+        this.value = await this.literal()
+        other = args[0] && await args[0].literal()
+        
+        method = this[method]
+        if (typeof method === 'function'){
+          result = await method(other, args, {call_config})
+        }else {
+          result = await this.overloads(method_name, other, args, {call_config, thread, chain})
+        }
+        break;
+      case 'array':
+        if (method === 'call') method = 'call_'
+        method = this[method]
+        if(typeof method === 'function'){
+          result = await method(args[0], args, {call_config, thread, chain})
+        }
+        break;
+      case 'twain':
+        if(['set', 'get'].includes(method)){
+          method = `${method}_`
+        }
+        method = this[method]
+        if (typeof method === 'function'){
+          result = await method(args[0], args, {call_config, thread, chain})
+        }
+        break;
+      case 'function':
+        method = this[method]
+        if (typeof method === 'function'){
+          result = await method(args[0], args, {call_config, thread, chain})
+        }
+        break;
+      case 'instance':
+        method = this[method]
+        if(typeof method === 'function'){
+          result = await method(args[0], args, {call_config, chain})
+        }
+        break;
+      case 'class':
+        method = this[method]
+        if (typeof method === 'function'){
+          result = await method(args[0], args, {call_config, thread, chain})
+        }
+        break;
+      default:
+        method = this[method]
+        if (typeof method === 'function'){
+          result = await method(args[0], args, {call_config, thread, chain})
+        }
+      ;
+    }
+
+    if(pure){
+      return result;
+    }
+
+    if (result && result.__interrupt__){}
+    else if (result && ['address', 'folder'].includes(result.type)){
+    }else result = await this.account.vm.parse_aircode(result, {
+      config: call_config,
+      chain
+    })
+    
+    return result
+  }
+
+  overloads = async (name, other, args)=>{
+    let lit = await this.literal(), result;
+
+    switch(this.type){
+      case "string":
+        switch(name){
+          case '__eq__':
+            result = lit === other
+            break;
+          case '__ne__':
+            result = lit !== other
+            break;
+          case '__lt__':
+            result = lit < other;
+            break;
+          case '__lte__':
+            result = lit <= other;
+            break;
+          case '__gt__':
+            result = lit > other;
+            break;
+          case '__or__':
+            result = lit || other;
+            break;
+          case '__and__':
+            result = lit && other;
+            break;
+          case '__gte__':
+            result = lit >= other;
+            break;
+          case '__mul__':
+            result = await this.repeat(other, args)
+            break;
+          case '__add__':
+            result = await this.concat(other, args)
+            break
+        }
+        break;
+    }
+
+    return result
+  }
+
+  ref = ()=>{
+    return `${this.address || this.config.address}/${this.config._id}`
+  }
+
+  get_ =async(prop)=>{
+    if (!this.methods[prop] && !this[prop]) return;
+
+    return {
+      type: 'address',
+      object: this.ref(),
+      value: prop
+    }
+  }
+
+  get = async(prop, options={})=>{
+    let {obj, raw} = options
+    let result;
+    
+    if (this.type === 'twain' && this.is_literal){
+      if (Object.keys(this.methods).includes(prop)){
+        return {
+          type: 'address',
+          value: prop,
+          object: this.ref()
+        }
+      }
+    }
+
+    if (this.account.vm.datatypes.includes(this.type) || this.type === 'error' || ['function', 'class'].includes(this.type)){
+      if(this.type === 'void' && !Object.keys(this.methods).includes(prop)){
+        result = await this.account.vm.throw_error({type: "ValueError", message: "Cannot subset a void value"})
+      } else if(this.type === 'function'){
+        result = await this.get_(prop)
+      } else if (this.type === 'twain'){
+        result = await this.get_(prop)
+      }else if (options.obj && options.obj.type === 'number' && ['array', 'string'].includes(this.type)){
+        if (this.type === 'array')
+          result = await this.index(prop)
+        else {
+          result = await this.call('index', {
+            chain: this.account.chain,
+            call_config: {arguments: [options.config], location: this.spawn_address()}
+          })
+        }
+      } else if (!prop.includes('/')){
+        if (this.methods[prop])
+          result = {
+            type: 'address',
+            value: prop,
+            object: this.ref()
+          }
+          if (['function', 'class'].includes(this.type)){
+            result.config = true;
+          }
+      }
+    }else if(this.type === 'instance'){
+      result = await this.get_(obj? await obj.literal() :prop)
+    } else if(this.type === 'folder'){
+      result = await this.get_(obj? await obj.literal() : prop)
+    }
+    if (!result && !raw){
+      result = await this.account.vm.statics({type:'void'})
+    }
+
+    return result
+  }
+
+  set = async(prop, value, options)=>{
+    let {chain} = options;
+
+    if (this.type === 'twain'){
+      await this.call('set', {call_config: {arguments: [prop, value], location: this.spawn_address()}, chain})
+    }else if(this.type === 'instance' || this.type === 'function'){
+      return await this.set_(prop, value)
+    }
+  }
+
+  chain =async ()=>{
+    if (this.chn || !this.address)return this.chn;
+
+    this.chn = await this.account.chain.chain(this.address)
+
+    return this.chn
+  }
+
+  sync = async()=>{
+    return this
+  }
+
+  spawn_address = (spw)=>{
+    return `${this.address}_${spw || Math.random().toString().slice(3)}`
+  }
+
+  _split_datapath = (datapath)=>{
+    datapath = datapath.split('/')
+
+    return [datapath.slice(0,-1).join('/'), datapath.slice(-1)[0]]
+  }
+
+  to_address = async()=>{
+    let o = {
+      type: 'address',
+      value: this.address || this.config.location,
+      _id: this.config._id,
+    }
+    if (this.value && this.value.object) o.object = this.value.object
+
+    if (['function', 'class'].includes(this.type)){
+      o.config = true
+      o.value = this.config.address
+    }
+    o.module = this.config.module
+    
+    if (this.is_literal) {
+      o.is_literal = true
+    }
+
+    return o
   }
 
-  retrieve = async (options)=>{
-    return await this.oracle.read(this.path, options)
+  sync = async()=>{
+    return this
   }
 }
 

package/Datatypes/functions/wallet.js

@@ -0,0 +1,49 @@
+class Wallet{
+  constructor(instance){
+    this.instance = instance;
+  }
+
+  transfer = async(price, recipient)=>{
+    let {vm} = this.instance.account
+    let folder = await this.instance._folder()
+    let wallet_folder = await folder.child('wallet')
+    let tok = await (await wallet_folder.readone({_id: price.token})).literal()
+    if (!tok) return {successful: false, message:"Doesn't have token"}
+    if(tok.value< price.value) return {successful: false, message:"Insufficient balance"}
+
+    await wallet_folder.update({_id: tok._id}, {value: {$dec: price.value}})
+
+    let transactions = await wallet_folder.child(price.token)
+    let recent_tx = await (await transactions.readone()).literal()
+    let tx = {value: price.value, previous: await vm.hash(recent_tx), recipient: recipient.ref(), timestamp: Date.now()}
+    tx.hash = await vm.hash(tx)
+
+    let res = await transactions.write(tx)
+    await wallet_folder.child('transactions').write(await res.to_address())
+
+    let recipient_folder = await recipient._folder()
+    let recipient_wallet = await recipient_folder.child('wallet'), sender_ref = `${res.ref()}:${tx.hash}`;
+    let rec_tok = await recipient_wallet.readone({_id: price.token})
+    let rec_txs = await recipient_wallet.child(price.token), rec_tx;
+
+    if(!rec_tok){
+      await recipient_wallet.write({_id: price.token, value: price.value})
+      rec_tx = {
+        value: price.value, previous: 'genesis', sender_ref
+      }
+      rec_tx.hash = await vm.hash(rec_tx)
+      await rec_txs.write(rec_tx)
+    }else {
+      await recipient_wallet.update({_id: price.token}, {value: {$inc: price.value}})
+      let rec_prev_tx = await (await rec_txs.readone()).literal()
+      rec_tx = {value: price.value, previous: await vm.hash(rec_prev_tx), sender_ref}
+      rec_tx.hash = await vm.hash(rec_tx)
+
+      await rec_txs.write(rec_tx)
+    }
+    
+    return {successful: true, message: 'Transfer completed.'}
+  }
+}
+
+export default Wallet;