godprotocol 1.0.79 → 1.0.82

package/Objects/Manager.js

@@ -1,99 +1,77 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports["default"] = void 0;
-var _framer = _interopRequireDefault(require("../framer"));
-var _opcodes = _interopRequireDefault(require("../opcodes"));
-var _Account = _interopRequireDefault(require("./Account"));
-var _Blockweb = _interopRequireDefault(require("./Blockweb"));
-var _Oracle = _interopRequireDefault(require("./Oracle"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
-function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
-function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
-function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
-function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
-function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-var Manager = /*#__PURE__*/_createClass(function Manager() {
-  var _this = this;
-  _classCallCheck(this, Manager);
-  _defineProperty(this, "start_clock", function () {
-    var frequency = Number(process.env.HERTS) || 10;
-    _this.clock = setInterval(function () {
-      for (var account in _this.tracks) {
-        var track = _this.tracks[account];
-        var instruction = track.sequence[track.pointer];
-        track.account.vm.execute(instruction, track);
-        track.pointer++;
-        if (track.pointer === track.sequence.length) {
-          _this.running--;
-          track.account.chain.mine(track.account.vm);
-          track.account.flush_buffer(track.pids.splice(-1)[0]);
-          delete _this.tracks[account];
+import framer from "../framer";
+import opcodes from "../opcodes";
+import Account from "./Account";
+import Blockweb from "./Blockweb";
+import Oracle from "./Oracle";
+
+class Manager {
+  constructor() {
+    this.accounts = new Object();
+    this.running = 0;
+    this.tracks = new Object();
+    this.web = new Blockweb(this);
+    this.oracle = new Oracle(this);
+  }
+
+  start_clock = () => {
+    let frequency = Number(process.env.HERTS) || 10;
+    this.clock = setInterval(() => {
+      for (let account in this.tracks) {
+        let track = this.tracks[account];
+        let program = track.slice(-1)[0];
+
+        let instruction = program.sequence[program.pointer];
+
+        program.account.vm.execute(instruction, program);
+        program.pointer++;
+
+        if (program.pointer === program.sequence.length) {
+          program.account.flush_buffer(program.pid);
+
+          track.pop();
         }
-        if (track.breakpoint.slice(-1)[0] === track.pointer) {
-          track.account.flush_buffer(track.pids.splice(-1)[0]);
+        if (!track.length) {
+          this.running -= 1;
+          delete this.tracks[account];
+          program.account.chain.mine(program.account.vm);
         }
       }
-      !_this.running && clearInterval(_this.clock);
+
+      !this.running && clearInterval(this.clock);
     }, frequency);
-  });
-  _defineProperty(this, "get_account", function (name) {
-    return _this.accounts[name];
-  });
-  _defineProperty(this, "add_account", function (name, meta) {
-    var account = _this.get_account(name);
+  };
+
+  get_account = (name) => this.accounts[name];
+
+  add_account = (name, meta) => {
+    let account = this.get_account(name);
+
     if (!account) {
-      account = new _Account["default"](name, _objectSpread(_objectSpread({}, meta), {}, {
-        manager: _this
-      }));
-      (0, _framer["default"])(account);
-      (0, _opcodes["default"])(account);
-      _this.accounts[account.name] = account;
-    } else if (meta && meta["private"] && !account["private"]) {
-      account["private"] = true;
+      account = new Account(name, { ...meta, manager: this });
+      opcodes(account);
+      framer(account);
+
+      this.accounts[account.name] = account;
+    } else if (meta && meta.private && !account.private) {
+      account.private = true;
     }
+
     return account;
-  });
-  _defineProperty(this, "push", function (program) {
-    var track = _this.tracks[program.account.name];
+  };
+
+  push = (program) => {
+    let track = this.tracks[program.account.name];
+
     if (track) {
-      var _track$sequence;
-      track.breakpoint.push(track.pointer + program.sequence.length + 1);
-      (_track$sequence = track.sequence).splice.apply(_track$sequence, [track.pointer + 1, 0].concat(_toConsumableArray(program.sequence)));
-      track.pids.push(program.pid);
-      if (!_this.running) {
-        _this.running++;
-        _this.tracks[program.account.name] = track;
-        _this.start_clock();
-      }
+      track.push({ ...program, pointer: 0 });
     } else {
-      track = _objectSpread(_objectSpread({}, program), {}, {
-        pointer: 0,
-        pids: [program.pid],
-        breakpoint: new Array()
-      });
-      _this.tracks[track.account.name] = track;
-      _this.running++;
-      _this.running === 1 && _this.start_clock();
+      track = [{ ...program, pointer: 0 }];
+      this.tracks[program.account.name] = track;
+
+      this.running++;
+      this.running === 1 && this.start_clock();
     }
-  });
-  this.accounts = new Object();
-  this.running = 0;
-  this.tracks = new Object();
-  this.web = new _Blockweb["default"](this);
-  this.oracle = new _Oracle["default"](this);
-});
-var _default = Manager;
-exports["default"] = _default;
+  };
+}
+
+export default Manager;

package/Objects/Opcodes.js

@@ -1,39 +1,46 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports["default"] = void 0;
-var _functions = require("../utils/functions");
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
-function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
-function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-var Opcodes = /*#__PURE__*/_createClass(function Opcodes() {
-  var _this = this;
-  _classCallCheck(this, Opcodes);
-  _defineProperty(this, "set", function (opcode, circuit) {
-    _this.opcodes[opcode] = circuit;
-    _this.account.compiler.opcodes.push(opcode);
-  });
-  _defineProperty(this, "prepare_operation", function (opcode, context) {
-    var circ = _this.opcodes[opcode];
+import { obj } from "../framer";
+import { transpile_object } from "../utils/functions";
+
+class Opcodes {
+  constructor() {
+    this.opcodes = new Object();
+  }
+
+  set = (opcode, circuit) => {
+    this.opcodes[opcode] = circuit;
+    obj.Opcodes[opcode] = null;
+
+    this.account.assembler.opcodes.push(opcode);
+  };
+
+  prepare_operation = (opcode, context) => {
+    let circ = this.opcodes[opcode];
+
     if (typeof circ !== "function") return;
-    var buf = context.get_buffer();
-    var args = buf && context.account.read(buf.inputs);
-    var res = circ(args);
-    _this.stdin(res);
-  });
-  _defineProperty(this, "stdin", function (object) {
+
+    let buf = context.get_buffer();
+
+    let args =
+      context.account.read(buf && buf.inputs) ||
+      this.account.stdin.splice(-1)[0];
+
+    let res = circ(args, this);
+
+    this.stdin(res);
+  };
+
+  stdin = (object, cb) => {
     if (object == null) return;
-    var code_string = (0, _functions.transpile_object)(object);
-    _this.account.compiler.run(code_string, true);
+
+    this.flags.zero = !object;
+    if (typeof object === "number") this.flags.neg = object < 0;
+
+    let code_string =
+      typeof object !== "string" ? JSON.stringify(object) : object;
+
+    this.account.assembler.run(code_string, { cb, pure: true });
     // console.log(`Writing in: ${code_string}`);
-  });
-  this.opcodes = new Object();
-});
-var _default = Opcodes;
-exports["default"] = _default;
+  };
+}
+
+export default Opcodes;

package/Objects/Oracle.js

@@ -1,42 +1,65 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports["default"] = void 0;
-var _fs = _interopRequireDefault(require("fs"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
-function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
-function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-var Oracle = /*#__PURE__*/_createClass(function Oracle(mgr) {
-  var _this = this;
-  _classCallCheck(this, Oracle);
-  _defineProperty(this, "set", function (path, _ref) {
-    var type = _ref.type,
-      obj = _ref.obj;
-    _this.datapaths[path] = {
-      obj: obj,
-      type: type
-    };
-  });
-  _defineProperty(this, "get", function (path) {
-    return _this.datapaths[path];
-  });
-  _defineProperty(this, "write", function (addr, data) {
-    var meta = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
-      encoding: "utf-8"
+import fs from "fs";
+import GDS from "generalised-datastore";
+import { hash } from "../utils/hash";
+
+class Oracle {
+  constructor(mgr) {
+    this.fs = fs;
+    this.mgr = mgr;
+    this.datapaths = new Object();
+    this.gds = new GDS("godprotocol").sync();
+  }
+
+  set = (path, { type, obj }) => {
+    this.datapaths[path] = {
+      obj,
+      type,
     };
+  };
+
+  get = (path) => this.datapaths[path];
+
+  hash = (data) => {
+    data = JSON.stringify(data);
+    return hash(hash);
+  };
+
+  write = (addr, data, account) => {
     if (typeof data !== "string") data = JSON.stringify(data);
-    _this.fs.writeFileSync(addr, data, meta);
-  });
-  this.fs = _fs["default"];
-  this.mgr = mgr;
-  this.datapaths = new Object();
-});
-var _default = Oracle;
-exports["default"] = _default;
+
+    let folder = this.gds.folder(
+      hash(account.vm.get_context().physical_address)
+    );
+    folder.write({ data: addr });
+
+    this.fs.writeFileSync(addr, data, { encoding: "utf-8" });
+  };
+
+  fetch = (payload, callback) => {
+    let { physical_address, query, account, signature } = payload,
+      result;
+
+    account = this.mgr.get_account(account);
+    if (account && account.private)
+      if (!account.validate({ physical_address, query }, signature, callback))
+        return;
+
+    try {
+      let operation = this.gds.folder(hash(physical_address))[query.operation];
+
+      result = operation && operation(query.query, query.options);
+
+      if (result) {
+        if (account) {
+          let content = account.read(result.data);
+          if (content != null) result.content = content;
+        }
+      }
+    } catch (e) {
+      result = { error: true, message: e.message, payload };
+    }
+    typeof callback === "function" && callback(result);
+  };
+}
+
+export default Oracle;

package/Objects/Virtual_machine.js

@@ -1,128 +1,136 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports["default"] = void 0;
-var _Opcodes2 = _interopRequireDefault(require("./Opcodes"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
-function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
-function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
-function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
-function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
-function _createSuper(t) { var r = _isNativeReflectConstruct(); return function () { var e, o = _getPrototypeOf(t); if (r) { var s = _getPrototypeOf(this).constructor; e = Reflect.construct(o, arguments, s); } else e = o.apply(this, arguments); return _possibleConstructorReturn(this, e); }; }
-function _possibleConstructorReturn(t, e) { if (e && ("object" == _typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return _assertThisInitialized(t); }
-function _assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
-function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
-function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-var Virtual_machine = /*#__PURE__*/function (_Opcodes) {
-  _inherits(Virtual_machine, _Opcodes);
-  var _super = _createSuper(Virtual_machine);
-  function Virtual_machine(_context) {
-    var _this;
-    _classCallCheck(this, Virtual_machine);
-    _this = _super.call(this);
-    _defineProperty(_assertThisInitialized(_this), "get_context", function (index) {
-      return _this.contexts.slice(index == null ? -1 : index)[0];
-    });
-    _defineProperty(_assertThisInitialized(_this), "parse_arg", function (arg, is_cursor) {
-      var context = _this.get_context();
-      var args = arg.split("/"),
-        i = 0;
-      while (args[0] === "..") {
-        i++;
-        args.splice(0, 1);
-      }
-      i = (i + 1) * -1;
-      context = i ? _this.get_context(i) : context;
-      arg = args.join("/");
-      while (arg.includes("^")) {
-        var blk = context.connections.slice(-1)[0];
-        if (!blk) break;
-        context = blk.chain;
-        var _i = arg.indexOf("^");
-        arg = "".concat(arg.slice(0, _i)).concat(arg.slice(_i + 1));
-      }
-      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;
-    });
-    _defineProperty(_assertThisInitialized(_this), "split_instruction", function (instruction) {
-      var split = instruction.split(" ");
-      var opcode = split[0],
-        args = split.slice(1).join(" ");
-      return {
-        opcode: opcode,
-        args: args
-      };
-    });
-    _defineProperty(_assertThisInitialized(_this), "execute", function (instruction, track) {
-      _this.track = track;
-      if (!instruction) return;
-      var _this$split_instructi = _this.split_instruction(instruction),
-        opcode = _this$split_instructi.opcode,
-        args = _this$split_instructi.args;
-      var context = _this.get_context();
-      if (!context) return;
-      context.add_tx(instruction);
-      var chain;
-      args = _this.parse_arg(args, opcode === "cursor");
-      switch (opcode) {
-        case "chain":
-          chain = context.account.add_chain(args, context);
-          _this.contexts.push(chain);
-          chain.append_buffer();
-          break;
-        case "link":
-          chain = context.account.manager.web.get(args);
-          if (!chain) {
-            console.log("LINKing Failed. - ".concat(args));
-            return;
-          }
-          chain.append_buffer();
-          _this.contexts.push(chain);
-          break;
-        case "mine":
-          var bloc = context.mine(_assertThisInitialized(_this), true);
-          _this.account.buff(bloc, _this.track.pid);
-          break;
-        case "pop":
-          var blk;
-          if (context.txs.length > 1) {
-            blk = context.mine(_assertThisInitialized(_this));
-          } else {
-            blk = context.get_latest_block();
-            if (blk) _this.get_context(-2).connections.push(blk);
-            context.txs = [];
-          }
-          blk && _this.account.buff(blk, _this.track.pid);
-          _this.contexts.pop();
-          break;
-        case "cursor":
-          context.set_cursor(args);
-          break;
-        case "write":
-          context.account.write(args, context);
-          break;
-        default:
-          _this.prepare_operation(opcode, context);
-          break;
-      }
-    });
-    _this.account = _context.account;
-    _this.contexts = [_context];
-    _this.stack = new Array();
-    return _this;
+import Opcodes from "./Opcodes";
+
+class Virtual_machine extends Opcodes {
+  constructor(context) {
+    super();
+
+    this.account = context.account;
+    this.contexts = [context];
+    this.stack = new Array();
+    this.flags = {
+      neg: false,
+      equal: false,
+      zero: false,
+    };
   }
-  return _createClass(Virtual_machine);
-}(_Opcodes2["default"]);
-var _default = Virtual_machine;
-exports["default"] = _default;
+
+  get_context = (index) => {
+    return this.contexts.slice(index == null ? -1 : index)[0];
+  };
+
+  parse_arg = (arg, is_cursor) => {
+    let context = this.get_context();
+
+    let args = arg.split("/"),
+      i = 0;
+
+    while (args[0] === "..") {
+      i++;
+
+      args.splice(0, 1);
+    }
+
+    i = (i + 1) * -1;
+    context = i ? this.get_context(i) : context;
+
+    arg = args.join("/");
+
+    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)}`;
+    }
+
+    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;
+  };
+
+  split_instruction = (instruction) => {
+    let split = instruction.split(" ");
+    let opcode = split[0],
+      args = split.slice(1).join(" ");
+
+    return { opcode, args };
+  };
+
+  execute = (instruction, track) => {
+    this.track = track;
+
+    if (!instruction) return;
+
+    let { opcode, args } = this.split_instruction(instruction);
+
+    let context = this.get_context();
+
+    if (!context) return;
+
+    context.add_tx(instruction);
+
+    // console.log(instruction);
+
+    let chain;
+
+    args = this.parse_arg(args, opcode === "cursor");
+
+    switch (opcode) {
+      case "chain":
+        chain = context.account.add_chain(args, context);
+        this.contexts.push(chain);
+
+        chain.append_buffer();
+
+        break;
+      case "link":
+        chain = context.account.manager.web.get(args);
+
+        if (!chain) {
+          console.log(`LINKing Failed. - ${args}`);
+          return;
+        }
+
+        chain.append_buffer();
+
+        this.contexts.push(chain);
+
+        break;
+      case "mine":
+        let bloc = context.mine(this, true);
+
+        this.account.buff(bloc, this.track.pid);
+
+        break;
+      case "pop":
+        let blk;
+        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 = [];
+        }
+        blk && this.account.buff(blk, this.track.pid);
+
+        this.contexts.pop();
+        break;
+      case "cursor":
+        context.set_cursor(args);
+        break;
+      case "write":
+        context.account.write(args, context);
+        break;
+      default:
+        this.prepare_operation(opcode, context);
+        break;
+    }
+  };
+}
+
+export default Virtual_machine;