godprotocol 1.1.2 → 1.1.31

package/Datatypes/num.js

@@ -1,10 +1,180 @@
 import Storage from "./functions/storage";
 
 class Num extends Storage {
-  constructor(value) {
-    super();
+  constructor(config, manager) {
+    super(manager)
 
-    this.value = value;
+    this.config = config
+    this.type = 'number'
+  }
+
+  call = async (name, args)=>{
+    let result, other, me = await this.literal();
+
+    other = args[0] && await args[0].literal()
+    switch(name){
+      case '__add__':
+        result = me + other;
+        break;
+      case '__sub__':
+        result = me - other;
+        break;
+      case '__mul__':
+        result = me * other;
+        break;
+      case '__div__':
+        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;
+  }
+
+  factorial = (value)=>{
+    if (value === 0)
+      return 1
+    return value * this.factorial(value - 1)
+  }
+
+  configs = (name)=>{
+    let conf = {__add__: {
+      parameters: [{name: 'other', position: 0}]
+    }}
+
+    return conf[name]
   }
 }
 

package/Datatypes/str.js

@@ -1,10 +1,137 @@
 import Storage from "./functions/storage";
 
 class Str extends Storage {
-  constructor(value) {
-    super();
+  constructor(config, manager) {
+    super(manager)
 
-    this.value = value;
+    this.config = config
+    this.type = 'string'
+  }
+
+  call = async (name, args)=>{
+    let result, other, me = await this.literal();
+
+    switch(name){
+      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':
+        other = args[0]
+        let lst = args[1] && await args[1].literal()
+        result = me[lst?'lastIndexOf': 'indexOf'](await other.literal())
+        break;
+      case 'includes':
+        other = args[0]
+        result = me.includes(await other.literal())
+        break;
+      case 'index':
+        other = await args[0].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;
+        breakl
+      case 'is_blank':
+        result = !!me.trim()
+        break;
+      case 'is_numeric':
+        result = !!me && !isNaN(Number(me))
+        break;
+      case "endswith":
+        result = me.endsWith(await args[0].literal())
+        break;
+      case "startswith":
+        result = me.startsWith(await args[0].literal())
+        break;
+      case 'padend':
+        result = me.padEnd(await args[0].literal(), await args[1].literal())
+        break;
+      case 'padstart':
+        result = me.padStart(await args[0].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 args[0].literal())
+        break
+      case 'replace':
+        let gl = args[2] && await args[2].literal(),
+        su = await args[0].literal(), rpl = await args[1].literal()
+        result = me.replace(su, rpl)
+        if (gl){
+          while(result.includes(su)) result = result.replace(su, rpl)
+        }
+        break
+      case "split":
+        break;
+      case 'charcode':
+        break;
+
+    }
+
+    return result;
   }
 }
 

package/Datatypes/twa.js

@@ -1,10 +1,88 @@
 import Storage from "./functions/storage";
 
 class Twa extends Storage {
-  constructor(value) {
-    super();
+  constructor(config, manager) {
+    super(manager);
 
-    this.value = value;
+    this.config = config
+    this.type = 'twain'
+  }
+
+  call = async(name, args, options)=>{
+    let {config, chain} = options
+    let me = await this.statics_()
+    let oracle = this.account.manager.oracle;
+
+    let spli = this.value.value.split('/');
+    let config_hash = spli.slice(-1)[0], store;
+
+    let other = args[0], result;
+
+    switch(name){
+      case 'set':
+
+        me[await oracle.hash(await other.literal(), 'sha1')] = [await this.account.vm.instance_address((await other.statics_())), await this.account.vm.instance_address((await args[1].statics_()))]
+
+        store = true;
+        break;
+      case 'get':
+        other = other && await other.literal();
+        result = me[await oracle.hash(other, 'sha1')]
+        result = result? {type:'address', value: result[1]}:null
+        break;
+      case 'entries':
+        result = new Array()
+        for (let prop in me){
+          let pair = me[prop]
+
+          let res = await this.account.vm.execute({
+            type:'call',
+            identifier: 'array',
+            arguments: [pair],
+            location: `${config.location}/${prop}`
+          }, {chain})
+          result.push(res.value);
+        }
+
+        break;
+      case "keys":
+        result = new Array()
+        for (let prop in me){
+          let pair = me[prop]
+          result.push(pair[0])
+        }
+        break;
+      case "values":
+        result = new Array()
+        for (let prop in me){
+          let pair = me[prop]
+          result.push(pair[1])
+        }
+        break;
+      case 'clear':
+        me = {}
+        store = true
+        break;
+      case 'remove':
+        other = other && await other.literal()
+        other = other && await oracle.hash(other, 'sha1')
+        result = Object(me).hasOwnProperty(other)
+        delete me[other]
+        store = true
+        break;
+      case 'copy':
+        result = me;
+        break;
+      case 'is_empty':
+        result = Array.from(Object.keys(me)).length === 0
+        break;
+    }
+
+    if (store){
+      await oracle.write(spli.slice(0,-1).join('/'), {type: this.type, values: me}, {config_hash, config: true})
+    }
+
+    return result;
   }
 }
 

package/Datatypes/voi.js

@@ -1,10 +1,10 @@
 import Storage from "./functions/storage";
 
 class Voi extends Storage {
-  constructor(value) {
-    super();
+  constructor(config, manager) {
+    super(config, manager);
 
-    this.value = value;
+    this.value = null;
   }
 }
 

package/Index.js

@@ -1,38 +1,5 @@
 import Trinity from "./Objects/Trinity";
 
-let trinity = new Trinity();
-
-const starter = async () => {
-  let manager = await trinity.add_manager("Arena_classic", {
-    server: {
-      port: 1408,
-      hostname: "127.0.0.1",
-      repo: true,
-    },
-    repositories: [
-      // {server}
-    ],
-  });
-
-  // let manager2 = await trinity.add_manager("Arena_classic", {
-  //   server: {
-  //     port: 1409,
-  //     hostname: "127.0.0.1",
-  //     repo: true,
-  //   },
-  //   sync_server: {
-  //     port: 1408,
-  //     hostname: "127.0.0.1",
-  //   },
-  //   repositories: [
-  //     // {server}
-  //   ],
-  // });
-
-  let account = await manager.add_account("lola");
-  // let account2 = await manager2.add_account("lola");
-};
-
-starter();
+let trinity = new Trinity(process.env.Trinity || "GodProtocol");
 
 export default trinity;

package/Objects/Account.js

@@ -1,62 +1,135 @@
+import Utils from "./Utils";
 import register from "../callables/register";
 import Chain from "./Chain";
 import Virtual_machine from "./Virtual_machine";
 
-class Account {
+class Account extends Utils {
   constructor(name, options) {
+    super();
+
     this.name = name;
 
     this.manager = options.manager;
+    this.parent = options.parent || this;
     this.repository = this.manager.repository;
+    this.account = this;
 
     this.physical_address = `Accounts/${name}`;
+    this.buffs = new Array();
+
+    this.chain = new Chain(this.physical_address, this.parent);
+    this.path = this.chain.path;
 
-    this.chain = new Chain(this.physical_address, this);
+    console.log(`Account Created: ${this.name}`);
   }
 
-  run = async (payload) => {
-    let { physical_address, query } = payload;
+  load = async (payload) => {
+    let { sequence: codes, account, physical_address, options } = payload;
+
+    console.log(payload);
+    if (account && account !== this.name) {
+      account = await this.manager.get_account(account);
+      if (account) {
+        return await account.load(payload);
+      } else return { error: true, message: "Account not found!" };
+    }
 
-    let chain = await this.vm.handle_chain(physical_address);
-    let codes = await chain.read(query);
+    if (typeof codes === "string") {
+      codes = await this.compiler.to_sequence(codes, physical_address);
+      if (options) {
+        codes = codes[0].body[options.line];
+      }
+    }
+    if (Array.isArray(codes)) {
+      codes = codes[0];
+    }
+
+    physical_address = `${this.physical_address}/${physical_address}`;
+
+    let chain = await this.chain.chain(physical_address);
 
-    await this.vm.execute(codes);
+    let res = { value: await chain.add_config(codes), type: "address" };
+
+    console.log(res, codes, chain.physical_address);
+    return res;
   };
 
-  load = async (payload) => {
-    let { sequence: codes, physical_address } = payload;
-
-    for (let c = 0; c < codes.length; c++) {
-      let instruction = codes[c];
-
-      if (["function", "class"].includes(instruction.type)) {
-        let addresses = await this.load({
-          ...instruction,
-          sequence: instruction.sequence,
-          physical_address: instruction.physical_address,
-        });
-        instruction.sequence = addresses;
-      }
+  run = async (payload) => {
+    let { physical_address, account, options } = payload;
+
+    let acc = (await this.manager.get_account(account)) || this;
+    let chain = await acc.chain.chain(
+      `${acc.physical_address}/${physical_address}`
+    );
+
+    console.log(chain.physical_address);
+    let config = await chain.read({ config: true });
+
+    if (options.env) {
+      let res = await this.load({
+        sequence: `env = ${JSON.stringify(options.env)}`,
+        physical_address: `${physical_address}`,
+        options: { line: 0 },
+      });
+      await this.vm.execute(res.value, { chain });
+    }
 
-      let chain = await this.vm.handle_chain(instruction.physical_address);
-      let block = await chain.write(instruction);
-      codes[c] = block.address;
+    let res = await this.vm.execute(config, { chain, main: true });
+    if (options && options.literal) {
+      if (res.type === "address") {
+        let conf = await this.vm.resolve_address(res.value);
+        res = {
+          address: res,
+          literal: await (await this.vm.cloth_content(conf)).literal(),
+        };
+      }
     }
-    let chain = await this.vm.handle_chain(physical_address);
-    await chain.write({ ...payload, sequence: codes });
 
-    return codes;
+    return res;
+  };
+
+  parse = async (payload) => {
+    let { account, physical_address, depth, history, query } = payload;
+
+    let acc = (await this.manager.get_account(account)) || this;
+    let chain = await acc.chain.chain(
+      `${acc.physical_address}/${physical_address}`
+    );
+
+    let config = await chain.read({ query, depth, history });
+    return config;
+  };
+
+  add_account = async (name, options) => {
+    let acc = new Account(name, {
+      ...options,
+      manager: this.manager,
+      parent: this,
+    });
+    await acc.sync();
+
+    return acc;
   };
 
   sync = async () => {
     this.servers = new Array();
     this.vm = new Virtual_machine(this);
+    this.compiler = new this.manager.compiler(this);
 
     await this.chain.sync();
     await this.vm.sync();
 
     await register(this);
   };
+
+  stringify = () => {
+    return {
+      physical_address: this.physical_address,
+      path: this.path,
+      name: this.name,
+      private: this.private,
+    };
+  };
 }
 
 export default Account;

package/Objects/Blockweb.js

@@ -1,36 +1,23 @@
-import Chain from "./Chain";
+class Blockweb{
+  constructor(mgr){
+    this.mgr = mgr;
 
-class Blockweb {
-  constructor(manager) {
-    this.manager = manager;
-
-    this.chains = new Object();
-    this.listeners = new Object();
+    this.chains = new Object()
   }
 
-  listen = async (physical_address, config) => {
-    let ls = this.listeners[physical_address];
-    if (!ls) {
-      ls = new Array();
-      this.listeners[physical_address] = ls;
+  set = async(physical_address, parent)=>{
+    let load = this.chains[physical_address]
+    if (!load){
+      load = {parents: new Object(), chains: new Array()}
+      this.chains[physical_address] = load
     }
-    ls.push(config.server);
-  };
-
-  spli_get = async (address, account) => {
-    return this.get(address) || (await this.set(address, account));
-  };
 
-  get = (address) => {
-    return this.chains[address];
-  };
+    load.parents[parent.physical_address] = parent;
+    let child = await parent.birth(physical_address)
+    load.chains.push(child)
 
-  set = async (address, account) => {
-    let chain = new Chain(address, account);
-    await chain.sync();
-
-    return chain;
-  };
+    return child;
+  }
 }
 
-export default Blockweb;
+export default Blockweb