godprotocol 1.0.7991 → 1.1.0

package/Objects/Virtual_machine.js

@@ -6,54 +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;
@@ -62,41 +131,47 @@ 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(`(${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) {
+          dim = [];
+          context.folder.config.dimensions = dim;
+        }
+        !dim.find((d) => d === args) && dim.push(args);
 
         chain.append_buffer();
 
         break;
       case "link":
-        chain = context.account.manager.web.get(args);
+        chain = this.handle_chain(args, context)
 
         if (!chain) {
-          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.pids.slice(-1)[0]);
+        this.push_context(chain);
 
         break;
       case "pop":
@@ -104,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.pids.slice(-1)[0]);
 
-        this.contexts.pop();
+        blk && this.account.buff(blk, this.track.pid);
+
+        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

@@ -1,65 +1,124 @@
 import Frame from "./Objects/Frame";
 
-const framer = (initiator) => {
-  let frame = new Frame({
-    Opcodes: {
-      add: null,
-      equal: null,
-      multiply: null,
-      subtract: null,
-      divide: null,
-      exp: null,
-      equal: null,
-      not_equal: null,
-      greater_than: null,
-      less_than: null,
-      gte: null,
-      lte: null,
+let obj = {
+  Opcodes: {
+    add: null,
+    equal: null,
+    multiply: null,
+    subtract: null,
+    divide: null,
+    exp: null,
+    equal: null,
 
-      send: null,
-      readonly: null,
-      socket_send: null,
+    send: null,
+    readonly: null,
+    socket_send: null,
 
-      jmp: null,
-      jmp_if: null,
-      hold: null,
+    jmp: null,
 
-      stdout: null,
-      stdin: null,
+    stdout: null,
+    stdin: null,
 
-      run: null,
-      load: null,
-      parse: null,
-      create_account: null,
+    run: null,
+    load: null,
+    parse: null,
+    create_account: null,
+  },
+  Datatypes: {
+    Number: null,
+    String: null,
+    Twain: null,
+    Array: null,
+    Void: null,
+    Boolean: null,
+  },
+  Objects: {
+    Blockchain: {
+      Chain: null,
+      Block: null,
+    },
+    Folder: {
+      active_file: null,
+      folder: null,
+      file: null,
     },
-    Datatypes: {
-      Number: null,
-      String: null,
-      Twain: null,
-      Array: null,
+    File: {
+      row: null,
+      parse: null,
+      column: null,
+      write: null,
     },
-    Objects: {
-      Blockchain: {
-        Chain: null,
-        Block: null,
-      },
-      Folder: {
-        active_file: null,
-        folder: null,
-        file: null,
-      },
-      File: {
-        row: null,
-        parse: null,
-        column: null,
-        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__'}},
     },
-  });
-  frame.to_instruction();
-  let instructions = frame.flatten_instructions();
+    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.account = initiator;
+  let start = Date.now();
+
+  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})
+  }
 
-  initiator.load({ program: { instructions } });
+  
 };
 
 export default framer;
+export { obj };

package/opcodes/add.js

@@ -4,12 +4,12 @@ let ops = [
   { name: "subtract", sign: "-" },
   { name: "divide", sign: "/" },
   { name: "exp", sign: "**" },
-  { name: "equal", sign: "==" },
-  { name: "not_equal", sign: "!=" },
-  { name: "greater_than", sign: ">" },
-  { name: "less_than", sign: "<" },
-  { name: "gte", sign: ">=" },
-  { name: "lte", 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 };