godprotocol 1.0.842 → 1.1.0

package/Objects/Virtual_machine.js

@@ -6,60 +6,123 @@ class Virtual_machine extends Opcodes {
 
     this.account = context.account;
     this.contexts = [context];
-    this.stack = new Array();
     this.flags = {
       neg: false,
       equal: false,
       zero: false,
       void: false,
     };
+
+    this.stacktrace = new Array()
+
+    this.error_manager = new Object()
   }
+  
+  push_int = (name, payload)=>{
+    let stacks = this.error_manager[name]
+    if (!stacks){
+      stacks = new Array()
+      this.error_manager[name] = stacks;
+    }
 
-  get_context = (index) => {
-    return this.contexts.slice(index == null ? -1 : index)[0];
-  };
+    stacks.push(payload)
+  }
 
-  parse_arg = (arg, is_cursor) => {
-    let context = this.get_context();
+  quit = (payload)=>{
+    let instruction = this.track.sequence[this.track.pointer-1]
+    if(instruction==='ret'){
+      this.account.buff({ret:payload.op0}, this.track.pid)
+    }
 
-    let args = arg.split("/"),
-      i = 0;
+    this.account.flush_buffer(this.track.pid, payload);
+    this.track.pointer = this.track.sequence.length;
+    this.pop_context()
+  }
 
-    while (args[0] === "..") {
-      i++;
+  stderr = (err_object)=>{
+    console.log(err_object)
+    let{name, message} = err_object;
 
-      args.splice(0, 1);
+    if (!name){
+      return this.quit(err_object)
     }
 
-    i = (i + 1) * -1;
-    context = i ? this.get_context(i) : context;
+    let all = this.error_manager['*']
+    let stacks = this.error_manager[name]
+
+    if (!stacks){
+      if(all){
+        all = all.slice(-1)[0]
+        let object = this.read_chain(`${this.error_instance_address}/${name}_`)
+        stacks = [{object, metadata: all.metadata, catch_pointer: all.catch_pointer}]
+
+        if(!object)return this.quit({message: `Unknown Error instance - ${name}`})
+      }
+      
+      if (!stacks)
+      return this.quit(err_object)
+    }else if(all){
+      // Check precedence within all and stacks name, how?
+    }
 
-    arg = args.join("/");
+    let obj_payload, s;
+    for(s = this.stacktrace.length - 1; s >= 0; s--){
+      let trace = this.stacktrace[s]
+      let should_break;
 
-    while (arg.includes("^")) {
-      let blk = context.connections.slice(-1)[0];
-      if (!blk) break;
-      context = blk.chain;
-      let i = arg.indexOf("^");
-      arg = `${arg.slice(0, i)}${arg.slice(i + 1)}`;
+      for (let t = stacks.length-1; t >= 0; t--){
+        obj_payload = stacks[t]
+        if(obj_payload.metadata.namespace === trace){
+          should_break = true
+          break;
+        }
+      }
+      if (should_break) break;
     }
 
-    if (arg.startsWith("{*") && is_cursor) {
-      arg = context.explore(arg.slice(2, -1));
-    } else if (arg.startsWith("{") && !is_cursor) {
-      arg = context.explore(arg.slice(1, -1));
-    }
 
-    return arg;
-  };
+    if (!obj_payload){
+      return this.quit(err_object)
+    }
 
-  split_instruction = (instruction) => {
-    let split = instruction.split(" ");
-    let opcode = split[0],
-      args = split.slice(1).join(" ");
+    if(obj_payload.metadata.alias){
+      // Instantiate error message as an aircode string object.
+      let message_string = `${obj_payload.metadata.namespace}/${this.id_hash(
+        message
+      )}`;
+      this.air_object(message, {
+        location: message_string,
+        callback: () => {
+          this.exec({
+            executable: obj_payload.object.set_message,
+            location: obj_payload.metadata.alias,
+            metadata: {
+              callback: () => {
+                this.slice_trace(s+1)
+
+                this.track = this.account.manager.set_track({account: this.account.name, physical_address: obj_payload.metadata.namespace, pointer: obj_payload.catch_pointer}, true)
+              },
+            },
+            arguments: {
+              argv: [
+                {
+                  address: message_string,
+                  position: 0,
+                },
+              ],
+              argc: 1,
+            },
+          });
+        },
+      });
+     
+    }else {
+      this.slice_trace(s-3)
+      
+      this.track = this.account.manager.set_track({account: this.account.name, physical_address: obj_payload.metadata.namespace, pointer: obj_payload.catch_pointer}, true)
 
-    return { opcode, args };
-  };
+    }
+  }
 
   execute = (instruction, track) => {
     this.track = track;
@@ -68,22 +131,26 @@ class Virtual_machine extends Opcodes {
 
     let { opcode, args } = this.split_instruction(instruction);
 
-    let context = this.get_context();
+    let context = this.get_context(-1);
 
     if (!context) return;
 
     context.add_tx(instruction);
 
-    // console.log(instruction);
+    // console.log(`(${track.pointer}/${track.sequence.length})>> ${instruction}`)
+    // this.account.log_output(`>> ${instruction}`);
 
     let chain;
 
-    args = this.parse_arg(args, opcode === "cursor");
+    args = this.parse_arg(args, opcode);
 
     switch (opcode) {
       case "chain":
-        chain = context.account.add_chain(args, context);
-        this.contexts.push(chain);
+        chain = this.handle_chain(args, context)
+
+        if(!chain)return this.stderr(`Chain error - ${args}`)
+       
+        this.push_context(chain);
 
         let dim = context.folder.config.dimensions;
         if (!dim) {
@@ -96,28 +163,15 @@ class Virtual_machine extends Opcodes {
 
         break;
       case "link":
-        chain = context.account.manager.web.get(args);
+        chain = this.handle_chain(args, context)
 
         if (!chain) {
-          this.account.flush_buffer(this.track.pid, {
-            error: true,
-            error_message: `LINKing Failed. - ${args}`,
-          });
-          this.track.pointer = this.track.sequence.length;
-
-          console.log(`LINKing Failed. - ${args}`);
-          return;
+         return this.stderr(`LINKing Failed. - ${args}`)
         }
 
         chain.append_buffer();
 
-        this.contexts.push(chain);
-
-        break;
-      case "mine":
-        let bloc = context.mine(this, true);
-
-        this.account.buff(bloc, this.track.pid);
+        this.push_context(chain);
 
         break;
       case "pop":
@@ -125,14 +179,31 @@ class Virtual_machine extends Opcodes {
         if (context.txs.length > 1) {
           blk = context.mine(this);
         } else {
-          blk = context.get_latest_block();
-          if (blk) this.get_context(-2).connections.push(blk);
-
-          context.txs = [];
+          if (this.account.initiated&& this.account.is_datatype(context)){
+            blk= context.mine(this)
+          }else {
+            blk = context.get_latest_block();
+            if(!blk || context.datapath){
+              if(context.datapath){
+                blk = context.fabricate_datapath_block()
+              }else blk = this.get_voided_block()
+            }
+            
+            if (blk){
+              if (blk.chain.physical_address!== `${this.account.physical_address}/Datatypes/Void`) this.flags.void = false
+
+              this.get_context(-2).connections.push(blk);
+            }
+
+            context.get_buffer()
+            context.txs = [];
+          }
+         
         }
+
         blk && this.account.buff(blk, this.track.pid);
 
-        this.contexts.pop();
+        this.pop_context();
         break;
       case "cursor":
         context.set_cursor(args);

package/Trinity.js

@@ -0,0 +1,20 @@
+import create_server from "./utils/create_server"
+import Manager from "./Objects/Manager";
+
+class Trinity{
+  constructor(){
+    this.manager = new Manager()
+  }
+
+  create_server = (app, settings)=>{
+    settings = settings||{}
+    create_server(app, {...settings, manager: this.manager})
+  }
+
+  account= name=>this.manager.get_account(name)
+
+  add_account = (name, meta) =>this.manager.add_account(name, meta)
+}
+
+
+export default Trinity

package/callables.js

@@ -0,0 +1,172 @@
+import { get, set } from "./Executables/functions/indices";
+import { display } from "./Executables/functions/display";
+import typecast from "./Executables/functions/typecast";
+import { ops } from "./opcodes/add";
+import operation from "./Executables/functions/op";
+import assign from "./Executables/functions/assign";
+import importcheck from "./Executables/functions/importcheck";
+import set_error_catch from "./Executables/functions/set_error_catch";
+import string_register from "./Executables/functions/string_register";
+import array_register from "./Executables/functions/array_register";
+import twain_register from "./Executables/functions/twain_register";
+import price_register from "./Executables/functions/price_register";
+import folder_register from "./Executables/functions/folder_register";
+import chain_register from "./Executables/functions/servers/chain_register";
+import block_register from "./Executables/functions/servers/block_register";
+import account_register from "./Executables/functions/servers/account_register";
+import len from "./Executables/functions/len";
+import { get_address, get_id } from "./Executables/functions/utils";
+import adm_register from "./Executables/functions/adminstrator/adm_register";
+
+const callables = account => {
+  let add_callable= account.vm.add_callable;
+
+  chain_register(account)
+  block_register(account)
+  account_register(account)
+  price_register(account)
+  folder_register(account)
+  string_register(account)
+  array_register(account)
+  twain_register(account)
+  adm_register(account)
+
+  add_callable('read_chain', {
+    callable:(args, vm, options)=> {
+      let res = account.vm.read_chain(args.address, args.options)
+
+      if (typeof options.location === 'string'){
+        vm.write_chain(res, options.location)
+      }
+      return res;
+    },
+    config: {
+      parameters: [
+        {name:'address', position:0,},
+        {name: 'options', position:1}
+      ]
+    }
+  })
+
+
+  add_callable('air_object', {
+    callable: (args, vm, options)=>{
+      vm.air_object(args.literal, options)
+    }, 
+    config:{
+      parameters: [
+        {name:'literal', position:0,}
+      ]
+    }
+  })
+
+  add_callable('display', {
+    callable: display,
+    config: {
+      parameters: [
+        {name:'data', position:0, spread: true}
+      ]
+    }
+  })
+
+  add_callable('importcheck', {
+    callable: importcheck,
+    config: {
+      parameters: [
+        {name:'address', position:0},
+        {name:'names', position:1, spread: true}
+      ]
+    }
+  })
+
+  add_callable('set_error_catch', {
+    callable: set_error_catch,
+    config: {
+      parameters: [
+        {name:'object', position:0},
+        {name:'metadata', position:1},
+      ]
+    }
+  })
+
+  add_callable('set', {
+    callable: set,
+    config: {
+      parameters: [
+        {name:'obj', position:0, },
+        {name:'prop', position:1, },
+        {name:'value', position:2, },
+      ]
+    }
+  })
+
+  add_callable('get', {
+    callable: get,
+    config: {
+      parameters: [
+        {name:'obj', position:0, },
+        {name:'prop', position:1, }
+      ]
+    }
+  })
+
+  add_callable('typecast', {
+    callable: typecast,
+    config: {
+      parameters: [
+        {name:'obj', position:0, },
+        {name:'type', position:1, }
+      ]
+    }
+  })
+
+  add_callable('assign', {
+    callable: assign,
+    config: {
+      parameters: [
+        {name:'value', position:0, }
+      ]
+    }
+  })
+
+  add_callable('get_address', {
+    callable: get_address,
+    config: {
+      parameters: [
+        {name:'object', position:0, }
+      ]
+    }
+  })
+
+  add_callable('get_id', {
+    callable: get_id,
+    config: {
+      parameters: [
+        {name:'object', position:0, }
+      ]
+    }
+  })
+
+  add_callable('len', {
+    callable: len,
+    config: {
+      parameters: [
+        {name:'object', position:0, }
+      ]
+    }
+  })
+
+  ops.map(op=>{
+    add_callable(`__${op.name}__`, {
+      callable: (args, vm, options)=> operation(args, vm, {...options, op: op.name}),
+      config: {
+        parameters: [
+          {name:'left', position:0},
+          {name:'right', position:1}
+        ]
+      }
+    })
+  })
+}
+
+export default callables;

package/framer.js

@@ -29,6 +29,8 @@ let obj = {
     String: null,
     Twain: null,
     Array: null,
+    Void: null,
+    Boolean: null,
   },
   Objects: {
     Blockchain: {
@@ -47,24 +49,75 @@ let obj = {
       write: null,
     },
   },
+  CONSTANTS:{
+    overload: {
+      __add__: {__type:'twain', value: {type:'string', static_value:'__add__'}},
+      __multiply__: {__type:'twain', value: {type:'string', static_value:'__multiply__'}},
+      __subtract__: {__type:'twain', value: {type:'string', static_value:'__subtract__'}},
+      __divide__: {__type:'twain', value: {type:'string', static_value:'__divide__'}},
+      __exp__: {__type:'twain', value: {type:'string', static_value:'__exp__'}},
+      __equal__: {__type:'twain', value: {type:'string', static_value:'__equal__'}},
+      // __not_equal__: {__type:'twain', value: {type:'string', static_value:'__not_equal__'}},
+      __lt__: {__type:'twain', value: {type:'string', static_value:'__lt__'}},
+      __lte__: {__type:'twain', value: {type:'string', static_value:'__lte__'}},
+      __gt__: {__type:'twain', value: {type:'string', static_value:'__gt__'}},
+      __gte__: {__type:'twain', value: {type:'string', static_value:'__gte__'}},
+    },
+    types: {
+      instance: {__type: 'twain', value: {type:'string', __address__:`Accounts/initiator/CONSTANTS/types/instance`, static_value: 'instance'}},
+      function: {__type:'string', value: {type:'string', __address__:`Accounts/initiator/CONSTANTS/types/function`, static_value: 'function'}},
+      boolean: {__type:'string',value: {type:'string', __address__:`Accounts/initiator/CONSTANTS/types/boolean`, static_value: 'boolean'}},
+      array: {__type:'string',value: {type:'string', __address__:`Accounts/initiator/CONSTANTS/types/array`, static_value: 'array'}},
+      twain: {__type:'string',value: {type:'string', __address__:`Accounts/initiator/CONSTANTS/types/twain`, static_value: 'twain'}},
+      number: { __type:'string', value: {type:'string', __address__:`Accounts/initiator/CONSTANTS/types/number`, static_value: 'number'}},
+      string: {__type:'string', value: {type:'string', __address__:`Accounts/initiator/CONSTANTS/types/string`, static_value: 'string'}},
+    }
+  },
 };
 
 const framer = (initiator, cb) => {
   let frame = new Frame(obj);
-  frame.to_instruction();
-  let instructions = frame.flatten_instructions();
-
+  frame.account = initiator;
   let start = Date.now();
-  initiator.load({
-    program: { instructions },
-    callback: (blks) => {
-      console.log(
-        `Account:${initiator.name} is ready in ${Date.now() - start}ms.`
-      );
 
-      cb && cb(blks);
-    },
-  });
+  let callback =  (blks) => {
+    console.log(
+      `Account:${initiator.name} is ready in ${Date.now() - start}ms.`
+    );
+
+    initiator.initiated = true
+
+    cb&&cb(blks)
+  }
+
+  /* Quick due diligence */
+  let oracle = initiator.manager.oracle,
+   obj_hash = oracle.hash(obj), 
+   globals = oracle.gds.folder('globals'),
+   quick_hashes = globals.readone({title:'quick_hashes'});
+
+  if(!quick_hashes){
+    quick_hashes = {title:"quick_hashes"}
+    let res = globals.write(quick_hashes)
+    quick_hashes._id = res._id
+    quick_hashes.created = res.created
+  }
+  if(quick_hashes.frame === obj_hash){
+    setTimeout(() => {
+      callback([])  
+    }, 0);
+  }else {
+    frame.to_instruction();
+    let instructions = frame.flatten_instructions();
+  
+    initiator.load({
+      program: { instructions },
+      callback,
+    });
+    globals.update({_id:quick_hashes._id}, {frame: obj_hash})
+  }
+
+  
 };
 
 export default framer;

package/opcodes/add.js

@@ -4,7 +4,12 @@ let ops = [
   { name: "subtract", sign: "-" },
   { name: "divide", sign: "/" },
   { name: "exp", sign: "**" },
-  { name: "equal", sign: "==" },
+  { name: "equal", sign: "==", jmp:true},
+  { name: "not_equal", sign: "!=", jmp:true},
+  { name: "gt", sign: ">",jmp:true },
+  { name: "lt", sign: "<", jmp:true },
+  { name: "lte", sign: "<=" , jmp:true},
+  { name: "gte", sign: ">=", jmp:true },
 ];
 
 export { ops };

package/opcodes/indices.js

@@ -1,5 +1,9 @@
 const getter = (args) => {
   let base = args.op0;
+
+  // console.log(args, 'getter.args')
+  if(!base)return base === ''?null: base
+  
   if (typeof base === "number") return base;
 
   if (typeof base === "string") return base[args.op1];
@@ -9,20 +13,70 @@ const getter = (args) => {
   return base[args.op1];
 };
 
-const setter = (args) => {
+const setter = (args, vm) => {
   let base = args.op0;
+  
   if (typeof base === "number") return base;
 
+  if(vm.is_readonly(args))return;
+
   if (typeof base === "string") {
-    base = `${base.slice(0, args.op2)}${args.op1}${base.slice(args.op2 + 1)}`;
+    if (args.op1 ===0 && base.length <= 1){
+      base = `${args.op2}${base}`
+    } else if (args.op1 ===-1){
+      base = `${base}${args.op2}`
+    } else base = `${base.slice(0, args.op1)}${args.op2}${base.slice(args.op1)}`;
   } else {
     if (Array.isArray(base)) {
-      if (args.op2 == null || args.op2 >= base.length) base.push(args.op1);
-      else base[args.op2] = args.op1;
-    } else base[args.op2] = args.op1;
+      if (args.op1<0|| args.op1 == null || args.op1 >= base.length) base.push(args.op2);
+      else base[args.op1] = args.op2;
+    } else base[args.op1] = args.op2;
   }
 
   return base;
 };
 
-export { setter, getter };
+const del = (args, vm)=>{
+  let base = args.op0
+
+  if (typeof base === 'number')return;
+
+  if(vm.is_readonly(args))return;
+
+  if (typeof base === 'string'){
+    if (args.op1 === 0){
+      base = base.slice(1)
+    }else if (args === -1){
+      base = base.slice(0, -1)
+    }else {
+      base = `${base.slice(0, args.op1)}${base.slice(args.op1+1)}`
+    }
+  }
+  else {
+    if (Array.isArray(base)){
+      base.splice(args.op1, 1)
+    }else delete base[args.op1]
+  }
+  return base;
+}
+
+const slice = (args, vm)=>{
+  let obj = args.op0
+  let indexes = args.op1
+  if (!Array.isArray(indexes))return vm.stderr(`Indexes must be an array`)
+
+  let res;
+
+  if (typeof obj === 'number' ||!obj)return null;
+
+  if (typeof obj === 'object' && !Array.isArray(obj)){
+    res = {}
+    indexes.map(i=>{
+      res[i] = obj[i]
+    })
+  }else res = obj.slice(indexes[0], indexes[1])
+
+  return res;
+}
+
+export { setter, getter , del, slice};

package/opcodes/jmp.js

@@ -8,6 +8,8 @@ const jmp = (args, vm, meta) => {
 
   if ((condition || !flag) && typeof args.op0 === "number") {
     vm.track.pointer = args.op0;
+
+    vm.pop_context()
   }
 };
 

package/opcodes/std.js

@@ -1,9 +1,12 @@
 const stdout = (args, vm) => {
   if (!args) return;
 
-  vm.account.stdout.push({ data: args, pid: vm.track.pid });
+ args&& args.op0&& vm.account.stdout.push({ data: args, pid: vm.track.pid });
 
-  for (let v in args) console.log(args[v]);
+  let logs = []
+  for (let v in args) logs.push(args[v].static_value == null ? null :args[v].static_value);
+
+  console.log(...logs)
 };
 
 export { stdout };