godprotocol 1.0.74 → 1.0.76

package/Objects/Account.js

@@ -1,4 +1,5 @@
 import Aircode from "../Aircode/main";
+import start from "../Index";
 import { hash } from "../utils/hash";
 import { post_request } from "../utils/services";
 import Chain from "./Chain";
@@ -47,35 +48,33 @@ class Account extends Filesystem {
     return account || this;
   };
 
-  manage_buffer = () => {
+  manage_buffer = (cb) => {
     let call_session = `${Date.now()}-${Math.random()}`;
-    this.mine_buffer[call_session] = [];
+    this.mine_buffer[call_session] = { blocks: [], cb };
 
     return call_session;
   };
 
   buff = (block, pid) => {
-    let blks = this.mine_buffer[pid];
-    if (!blks) return;
+    let bf = this.mine_buffer[pid];
+    if (!bf) return;
 
-    blks.push(block.stringify());
+    bf.blocks.push(block.stringify());
   };
 
-  flush_buffer = (cb, pid) => {
-    let blocks = this.mine_buffer[pid];
+  flush_buffer = (pid) => {
+    let buff = this.mine_buffer[pid];
 
-    cb && cb(blocks);
+    buff.cb && buff.cb(buff.blocks);
     delete this.mine_buffer[pid];
   };
 
   load = ({ instructions, account }, cb) => {
     account = this.get_account(account);
 
-    let pid = account.manage_buffer();
+    let pid = account.manage_buffer(cb);
 
     this.manager.push({ sequence: instructions, account, pid });
-
-    account.flush_buffer(cb, pid);
   };
 
   parse = ({ physical_address, account, query }, cb) => {
@@ -92,19 +91,17 @@ class Account extends Filesystem {
   run = ({ account, query, physical_address }, cb) => {
     account = this.get_account(account);
 
-    let pid = account.manage_buffer();
+    let pid = account.manage_buffer(cb);
 
     let context = physical_address
       ? this.manager.web.get({ physical_address }, true)
       : account.vm.get_context();
 
-    if (!context) return account.flush_buffer(cb, pid);
+    if (!context) return account.flush_buffer(pid);
 
     let blk = query ? context.explore(query) : context.get_block(0);
 
     blk && this.manager.push({ sequence: blk.data, account, pid });
-
-    account.flush_buffer(cb, pid);
   };
 
   add_server = (server) => {
@@ -124,6 +121,11 @@ class Account extends Filesystem {
     obj.servers = this.servers;
     obj.name = this.name;
     obj.data_tracks = this.data_tracks;
+    obj.hash = this.hash;
+    obj.chain = this.chain.stringify();
+    obj.physical_address = this.physical_address;
+
+    return obj;
   };
 
   distribute = (data) => {
@@ -162,7 +164,7 @@ class Account extends Filesystem {
     let account = this.accounts[name] || this.manager.accounts[name];
 
     if (!account) {
-      account = new Account(name, this.manager);
+      account = start(name, server);
       this.accounts[account.name] = account;
       this.manager.accounts[account.name] = account;
     }

package/Objects/Chain.js

@@ -78,6 +78,7 @@ class Chain extends Explorer {
     let obj = {};
 
     obj.physical_address = this.physical_address;
+    obj.height = this.blocks.length;
     obj.parent = this.parent.path;
     obj.account = this.parent.account.name;
     obj.name = this.name;

package/Objects/Explorer.js

@@ -4,6 +4,9 @@ class Explorer {
   chain_props = ["blocks"];
 
   explore = (query) => {
+    if (!query) return;
+
+    if (query.startsWith("{")) query = query.slice(1, -1);
     query = query.split(":");
 
     query[0] = query[0].split(".");

package/Objects/Manager.js

@@ -21,8 +21,15 @@ class Manager {
         track.account.vm.execute(instruction, track);
         track.pointer++;
 
+        if (track.breakpoint.slice(-1)[0] === track.pointer) {
+          track.account.flush_buffer(track.pid);
+          track.pid = track.pids.splice(-1)[0];
+        }
+
         if (track.pointer === track.sequence.length) {
           this.total--;
+          track.account.flush_buffer(track.pid);
+
           delete this.tracks[account];
         }
       }
@@ -38,12 +45,20 @@ class Manager {
     let track = this.tracks[program.account.name];
 
     if (!track) {
-      track = { ...program, sequence: [...program.sequence], pointer: 0 };
+      track = {
+        ...program,
+        sequence: [...program.sequence],
+        pointer: 0,
+        pids: [program.pid],
+        breakpoint: new Array(),
+      };
       this.tracks[track.account.name] = track;
       this.total++;
       this.total === 1 && this.start_clock();
     } else {
+      track.breakpoint.push(track.pointer + 1);
       track.sequence.splice(track.pointer + 1, 0, ...program.sequence);
+      track.pids.push(program.pid);
     }
   };
 }

package/Objects/Virtual_machine.js

@@ -53,6 +53,17 @@ class Virtual_machine extends Opcodes {
     return arg;
   };
 
+  run_block = () => {
+    if (!this.running) return;
+
+    let context = this.get_context();
+    let instructions = [];
+    for (let b = 0; b < context.blocks.length; b++) {
+      let blk = context.blocks[b];
+      // let last_ blk.data.slice(-1)[0]
+    }
+  };
+
   execute = (instruction, track) => {
     this.track = track;
 
@@ -66,6 +77,8 @@ class Virtual_machine extends Opcodes {
 
     let context = this.get_context();
 
+    if (!context) return;
+
     context.add_tx(instruction);
 
     let chain;
@@ -77,6 +90,7 @@ class Virtual_machine extends Opcodes {
         chain = context.parent.add_chain(args);
         this.contexts.push(chain);
 
+        this.run_block();
         chain.append_buffer();
 
         break;
@@ -93,6 +107,7 @@ class Virtual_machine extends Opcodes {
         chain.append_buffer();
 
         this.contexts.push(chain);
+        this.run_block();
 
         break;
       case "listen":
@@ -105,7 +120,9 @@ class Virtual_machine extends Opcodes {
 
         break;
       case "run":
+        this.running = true;
         this.account.run({ query: original_arg }, this.stdin);
+        this.running = false;
         break;
       case "pop":
         let blk;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "godprotocol",
-  "version": "1.0.74",
+  "version": "1.0.76",
   "description": "A data mediator.",
   "main": "Index.js",
   "types": "index.d.ts",

package/readme.md

@@ -0,0 +1,126 @@
+# God Protocol
+
+### A data mediator
+
+## Installation
+
+```
+npm install godprotocol --save
+```
+
+## Usage
+
+You can get overall comprehension in just 4 method calls.
+
+### Create an Account
+
+Accounts comes with their own VM, thereby providing concurrency on processes being executed.
+
+```js
+import { start } from "godprotocol";
+
+// Create an initial account
+let initiator = start(`public_key`, { private: true | false });
+// if private is set to `true`, communication to the account instance must be validated by sigining with the private key.
+// N.B your keypairs are generated offline.
+```
+
+| `Parameters` | Type           | Description                                                                                                                                 |
+| ------------ | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| `name`       | string         | Account names can be any valid variable string. Such as a Public Key                                                                        |
+| `private`    | object:boolean | default `false`, if set to true, then any payloads sent to the account must be signed using the private key belonging to the account `name` |
+
+### Load Instructions
+
+The load method is the second in the pipeline,
+It is used to set your programs into the network web,
+where its data can continue to be accessed, and subsequent
+calls can be made on the loaded program.
+
+## Usage
+
+```js
+initiator.load(
+  {
+    instructions: ["link Account/initiator/Datatypes/Number", "write 7", "pop"],
+    account: `public_key`,
+  },
+  cb
+);
+```
+
+Type `method`
+
+| `Parameters` | Type     | Destructure    | Description                                                                                                          |
+| ------------ | -------- | -------------- | -------------------------------------------------------------------------------------------------------------------- |
+| `program`    | object   | `instructions` | An array of opcode-operands generated by the [`Loader Sequence`](https://godprotocol-web.vercel.app/loader_sequence) |
+|              |          | `account`      | Account instance to load and execute the program in.                                                                 |
+| `cb`         | function |                | A function that is called with the blocks mined during the execution.                                                |
+
+### Run Program
+
+The run is technically the second in the pipeline.
+
+## Usage
+
+```js
+initiator.run(
+  {
+    physical_address: "Account/initiator/Datatypes/Number", // This points to a chain
+    query: { blocks: 0 }, // Basically saying, index 0 block in physical_address chain, run again its instructions.
+    account: `public_key`,
+  },
+  cb
+);
+// N.B If query is missing, then VM starts execution from the block-index-0
+```
+
+Type `method`
+
+| `Parameters` | Type     | Destructure        | Description                                                                                                                                                                                               |
+| ------------ | -------- | ------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `payload`    | object   | `physical_address` | [`Physical Addresses`](https://godprotocol-web.vercel.app/physical_address) are logical namespace locations of tokens. They are derived from the high-level representation of the program's instructions. |
+|              |          | `query`            | A valid blockweb explorer query, you can read the explorer documentation [here](https://godprotocol-web.vercel.app/explorer)                                                                              |
+|              |          | `account`          | Account instance to execute the instructions in.                                                                                                                                                          |
+| `cb`         | function |                    | A function that is called with the blocks mined during the execution.                                                                                                                                     |
+
+### Parse Result
+
+The parse is technically the third of the pipeline. It takes like parameters as the `run` method.
+
+## Usage
+
+It is used to read blocks and chains
+
+```js
+initiator.parse(
+  {
+    physical_address: "Account/initiator/Datatypes/Number", // This points to a chain
+    query: { blocks: 0 }, // Basically saying, index 0 block in physical_address chain, retrieve it.
+    account: `public_key`,
+  },
+  cb
+);
+// N.B If query isn't provided, then you parse the chain.
+```
+
+Type `method`
+
+| `Parameters` | Type     | Destructure        | Description                                                                                                                                                                                               |
+| ------------ | -------- | ------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `payload`    | object   | `physical_address` | [`Physical Addresses`](https://godprotocol-web.vercel.app/physical_address) are logical namespace locations of tokens. They are derived from the high-level representation of the program's instructions. |
+|              | object   | `query`            | A valid blockweb explorer query, you can read the explorer documentation [here](https://godprotocol-web.vercel.app/explorer)                                                                              |
+|              |          | `account`          | Account instance to execute the instructions in.                                                                                                                                                          |
+| `cb`         | function |                    | A function that is called with the blocks mined during the execution.                                                                                                                                     |
+
+See the [package source](https://github.com/immanuel-savvy/godprotocol.git) for more details.
+
+[npm-url]: https://npmjs.org/package/godprotocol
+[downloads-url]: https://npmjs.org/package/godprotocol
+
+## References
+
+[Web Documentation]('https://godprotocol-web.vercel.app')
+[`Physical Addresses`](https://godprotocol-web.vercel.app/physical_address)
+[Explorer](https://godprotocol-web.vercel.app/explorer)
+[`Loader Sequence`](https://godprotocol-web.vercel.app/loader_sequence)

package/utils/create_server.js

@@ -7,7 +7,7 @@ let PORT = 1901,
 const cb = (res, data) => {
   if (typeof data !== "string") data = JSON.stringify(data);
 
-  res.end(data);
+  res(data);
 };
 
 const create_server = async (initiator, serve) => {
@@ -43,11 +43,11 @@ const create_server = async (initiator, serve) => {
         let account = initiator.create_account(data.name, data.server);
         res.end(account.stringify(true));
       } else if (req.url === "/load") {
-        initiator.load(data, (datagram) => cb(res, datagram));
+        initiator.load(data, (datagram) => cb(res.end, datagram));
       } else if (req.url === "/parse") {
-        initiator.parse(data, (datagram) => cb(res, datagram));
+        initiator.parse(data, (datagram) => cb(res.end, datagram));
       } else if (req.url === "/run") {
-        initiator.run(data, (datagram) => cb(res, datagram));
+        initiator.run(data, (datagram) => cb(res.end, datagram));
       }
       if (serve && req.headers.host !== `${serve.domain}:${serve.port}`)
         console.log(`services:${req.url}`);