godprotocol 1.0.796 → 1.0.798

package/opcodes.js

@@ -1,42 +1,38 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports["default"] = void 0;
-var _add = require("./opcodes/add");
-var _jmp = require("./opcodes/jmp");
-var _std = require("./opcodes/std");
-var _services = require("./utils/services");
 // import { socket_send } from "./Socket";
+import { ops } from "./opcodes/add";
+import { hold, jmp, jmp_if } from "./opcodes/jmp";
+import { stdout } from "./opcodes/std";
+import { post_request } from "./utils/services";
 
-var opcodes = function opcodes(account) {
-  var set = account.vm.set;
-  _add.ops.map(function (op) {
-    set(op.name, function (args) {
+const opcodes = (account) => {
+  let set = account.vm.set;
+
+  ops.map((op) => {
+    set(op.name, (args) => {
       if (!args) return;
+
       try {
-        var result = eval("".concat(args.op0, " ").concat(op.sign, " ").concat(args.op1));
+        let result = eval(`${args.op0} ${op.sign} ${args.op1}`);
+
         return result;
       } catch (e) {
         console.log(e.message);
       }
     });
   });
-  set("hold", _jmp.hold);
-  set("jmp", _jmp.jmp);
-  set("jmp_if", _jmp.jmp_if);
-  set("send", function (data) {
-    return (0, _services.post_request)(data, account.vm.stdin);
-  });
+
+  set("hold", hold);
+  set("jmp", jmp);
+  set("jmp_if", jmp_if);
+
+  set("send", (data) => post_request(data, account.vm.stdin));
   // set("socket_send", socket_send);
 
-  set("stdout", _std.stdout);
-  ["run", "load", "parse", "create_account"].map(function (op) {
-    return set(op, function (arg) {
-      return arg && arg.op0 && account[op](arg && arg.op0);
-    });
-  });
+  set("stdout", stdout);
+
+  ["run", "load", "parse", "create_account"].map((op) =>
+    set(op, (arg) => arg && arg.op0 && account[op](arg && arg.op0))
+  );
 };
-var _default = opcodes;
-exports["default"] = _default;
+
+export default opcodes;

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "godprotocol",
-  "version": "1.0.796",
+  "version": "1.0.798",
   "description": "A data mediator.",
   "main": "Index.js",
-  "types": "index.d.ts",
+  "types": "types/index.d.ts",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "start": "nodemon -r esm Index.js",
-    "prepack": "npmignore --auto"
+    "prepack": "npmignore"
   },
   "author": "Savvy",
   "license": "ISC",

package/readme.md

@@ -10,135 +10,111 @@ npm install godprotocol --save
 
 ### Brief Description
 
-God Protocol makes data sharing and processing easy for apps. With simple APIs, developers can add advanced features like AI, distribution, and scaling. Here are the main endpoints:
+This package is developing a framework for the Web 4.0
+It is to help provide multiple compute instances for servers and also data flexibility and transactions.
 
-### Endpoints
+You can get overall comprehension in just 4 method calls.
 
-- [**/create_account:**](#create_account) Create a machine account.
-- [**/load:**](#load) Load instruction sequence to the server.
-- [**/run:**](#run) Execute the instruction sequence.
-- [**/parse:**](#parse) Retrieve and process results from the server.
+## Create an Account
 
----
-
-## /create_account
-
-The /create_account endpoint creates a new account in the God Protocol. This account is necessary for using other features and handling data and tasks in the decentralised system.
-
-### Example Usage
+Accounts comes with their own VM, thereby providing concurrency on processes being executed.
 
 ```js
-import manager from "godprotocol";
+import start from "godprotocol";
 
-let account = manager.add_account("name");
-let private_account = manager.add_account("public_key", { private: true });
+// Create an initial account
+let initiator = start(`name`, { 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
-
-- `name` (string): The name to associate with the new account.
-- `meta` (object): Optional. Configuration object for account settings. Use `{ private: true }` to create a [private account](https://godprotocol-web.vercel.app/accounts/private).
-
-| Parameter | Possible Values  | Default Value | Type    | Description                                                   |
-| --------- | ---------------- | ------------- | ------- | ------------------------------------------------------------- |
-| `name`    | Any string       | `initiator`   | string  | The name to associate with the new account.                   |
-| `meta`    | `{private:true}` | `{}`          | object  | Optional. Configuration object for account settings.          |
-| `private` | `true`, `false`  | `false`       | boolean | Nested in `meta`. Specifies if the account should be private. |
+| `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
+## Load Instructions
 
-The /load endpoint in the God Protocol framework loads a program with specified instructions and manages associated accounts.
+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.
 
-### Example Usage
+### Usage
 
 ```js
-account.load({
-  program: {
-    instructions: ["instruction1", "instruction2"],
-    account: "account_id",
+initiator.load(
+  {
+    instructions: ["link Account/initiator/Datatypes/Number", "write 7", "pop"],
+    account: `public_key`,
   },
-  signature: "signature_string",
-  callback: () => {
-    // Callback function logic
-  },
-});
+  cb
+);
 ```
 
-| **Paramters**          | **Possible Values**                                                                        | **Default Value** | **Type**               | **Description**                                                   |
-| ---------------------- | ------------------------------------------------------------------------------------------ | ----------------- | ---------------------- | ----------------------------------------------------------------- |
-| `program`              | `{ instructions: [], account: "" }`                                                        | None              | object                 | Object containing program instructions and associated account.    |
-| `program.instructions` | Array of [`instructions`](https://godprotocol-web.vercel.app/loader_sequence#instructions) | []                | array                  | Array of program instructions.                                    |
-| `program.account`      | Any string                                                                                 | `"initiator"`     | string                 | Associated account for program execution.                         |
-| `signature`            | String                                                                                     | None              | string                 | Optional. Signature for private account access.                   |
-| `callback`             | Function or `account.run{}`                                                                | None              | `function` or `object` | Optional. Function to call upon completion of the load operation. |
+Type `method`
 
-**Description:**
-The /load endpoint loads a program with instructions (`program.instructions`) and links it to an account (`program.account`). For private accounts, include a `signature` of the `program` for access. Optionally, provide a `callback` function to handle completion events, which may be additional execution payload (`account.run`).
+| `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`
+## Run Program
 
-The /run endpoint runs a program in the provided payload, physical address, and account details.
+The run is technically the second in the pipeline.
 
-### Example Usage
+### Usage
 
 ```js
-account.run({
-  payload: {
-    physical_address: "Accounts/name/path",
-    account: "account_id",
-    query: `blocks:0`,
-  },
-  signature: "signature_string",
-  callback: () => {
-    // Callback function logic
+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
 ```
 
-| Parameters                 | Possible Values                                                               | Default Value | Type                   | Descriptions                                                        |
-| -------------------------- | ----------------------------------------------------------------------------- | ------------- | ---------------------- | ------------------------------------------------------------------- |
-| `payload`                  | `{ physical_address: "", account: "", query: "" }`                            | None          | object                 | Object containing the physical address, account, and query details. |
-| `payload.physical_address` | Any [`physical_address`](https://godprotocol-web.vercel.app/physical_address) | None          | string                 | The physical address path for the account.                          |
-| `payload.account`          | Any string                                                                    | None          | string                 | Associated account for execution.                                   |
-| `payload.query`            | [`Query Strings`](https://godprotocol-web.vercel.app/explorer/query)          | None          | string                 | Query string to specify blocks or other parameters.                 |
-| `signature`                | String                                                                        | None          | string                 | Optional. Signature for private account access.                     |
-| `callback`                 | Function or `account.run{}`                                                   | None          | `function` or `object` | Optional. Function to call upon execution completion.               |
+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)                                                                              |
+|              | string   | `account`          | Account instance to execute the instructions in.                                                                                                                                                          |
+| `cb`         | function |                    | A function that is called with the blocks mined during the execution.                                                                                                                                     |
 
-**Description:**
-The /run endpoint in the God Protocol framework allows users to execute a program with a specified payload, which includes the physical address (`payload.physical_address`), associated account (`payload.account`), and query (`payload.query`). If the account is private, a payload `signature` is required. An optional `callback` function can be provided to handle completion events, which may include further execution instructions (`account.run`).
-If (`query`) is missing, then the most recent block's program in the chain is executed.
+## Parse Result
 
-## /parse Endpoint
+The parse is technically the third of the pipeline. It takes like parameters as the `run` method.
 
-The /parse endpoint parses data from a specified payload and returns matched blocks or the entire chain if no query is included.
+### Usage
 
-### Example Usage
+It is used to retrieve blocks and chains, and also extract their properties.
 
 ```js
-account.parse({
-  payload: {
-    physical_address: "Accounts/name/path",
-    account: "account_id",
-    query: "blocks:0",
+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`,
   },
-  signature: "signature_string",
-  callback: () => {
-    // Callback function logic
-  },
-});
+  cb
+);
+// N.B If query isn't provided, then you parse the chain.
 ```
 
-| Parameters                 | Possible Values                                                               | Default Value | Type                   | Descriptions                                                        |
-| -------------------------- | ----------------------------------------------------------------------------- | ------------- | ---------------------- | ------------------------------------------------------------------- |
-| `payload`                  | `{ physical_address: "", account: "", query: "" }`                            | None          | object                 | Object containing the physical address, account, and query details. |
-| `payload.physical_address` | Any [`physical_address`](https://godprotocol-web.vercel.app/physical_address) | None          | string                 | The physical address path for the account.                          |
-| `payload.account`          | Any string                                                                    | None          | string                 | Associated account for execution.                                   |
-| `payload.query`            | [`Query Strings`](https://godprotocol-web.vercel.app/explorer/query)          | None          | string                 | Query string to specify blocks or other parameters.                 |
-| `signature`                | String                                                                        | None          | string                 | Optional. Signature for private account access.                     |
-| `callback`                 | Function or `account.run{}`                                                   | None          | `function` or `object` | Optional. Function to call upon execution completion.               |
-
-**Description:**
-The /parse endpoint in the God Protocol framework parses data from the specified payload, which includes the physical address (`payload.physical_address`), associated account (`payload.account`), and an optional query (`payload.query`). If the account is private, a payload `signature` is required. An optional `callback` function can be provided to handle completion events, which may include further execution instructions (`account.run`). This endpoint returns the matched block to the callback if a query is included, or the entire chain of the path if no query is provided.
+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)                                                                              |
+|              | string   | `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.
 

package/types/Account.d.ts

@@ -0,0 +1,73 @@
+import Loader_sequence from "../Loader_sequence/main";
+import Filesystem from "./Filesystem";
+import Virtual_machine from "./Virtual_machine";
+
+interface Meta {
+  private?: boolean;
+  manager?: any;
+}
+
+interface Program {
+  instructions: string[];
+  account: string;
+}
+
+interface LoadPayload {
+  program: Program;
+  signature: string;
+  callback?: (data: any) => void;
+}
+
+interface ParsePayload {
+  payload: any;
+  signature: string;
+  callback?: (data: any) => void;
+}
+
+interface RunRequest {
+  payload: any;
+  signature: string;
+  callback?: (data: any) => void;
+}
+
+interface AccountPayload {
+  name: string;
+  meta?: Meta;
+}
+
+interface EndpointPayload {
+  [key: string]: any;
+}
+
+declare class Account extends Filesystem {
+  name: string;
+  private: boolean;
+  manager: any;
+  account: Account;
+  physical_address: string;
+  compiler: Loader_sequence;
+  chain: any;
+  vm: Virtual_machine;
+  mine_buffer: Record<string, any>;
+
+  constructor(name: string, meta?: Meta);
+
+  get_account(name: string): Account;
+  manage_buffer(callback?: (data: any) => void): string;
+  buff(block: any, pid: string): void;
+  flush_buffer(pid: string): void;
+  load(payload: LoadPayload): void;
+  parse(payload: ParsePayload): void;
+  run(request: RunRequest): void;
+  run_callback(callback: any, payload: any): void;
+  validate(
+    payload: any,
+    signature: string,
+    callback?: (data: any) => void
+  ): boolean;
+  stringify(str?: boolean): string | object;
+  create_account(payload: AccountPayload): Account;
+  endpoint(endpoint: string, payload: EndpointPayload): void;
+}
+
+export default Account;

package/types/Block.d.ts

@@ -0,0 +1,22 @@
+import Chain from "./Chain"; // Adjust the import according to your project structure
+
+declare class Block {
+  chain: Chain;
+  data: any;
+  metadata: Record<string, any>;
+  children: Block[];
+  index: number;
+  previous_hash?: string;
+  hash?: string;
+  cursor?: any;
+  datapath?: string;
+  timelapse?: any;
+
+  constructor(chain: Chain);
+
+  generate_hash(): void;
+  store(no_curs?: boolean): void;
+  stringify(str?: boolean): string | object;
+}
+
+export default Block;

package/types/Blockweb.d.ts

@@ -0,0 +1,14 @@
+import Chain from "./Chain";
+
+declare class Blockweb {
+  mgr: any;
+  physical_addresses: Record<string, string>;
+  chains: Record<string, Chain>;
+
+  constructor(mgr: any);
+
+  get(addr: string): Chain | undefined;
+  set(parent: any, name: string): Chain;
+}
+
+export default Blockweb;

package/types/Chain.d.ts

@@ -0,0 +1,35 @@
+import Block from "./Block";
+import Explorer from "./Explorer";
+
+declare class Chain extends Explorer {
+  parent: any;
+  account: any;
+  name: string;
+  physical_address: string;
+  pending_children: Block[];
+  connections: Block[];
+  blocks: Block[];
+  txs: any[];
+  height: number;
+  cursor: number;
+  cursors: number[];
+  buffs: any[];
+  start_time?: number;
+  hash: string;
+
+  constructor(parent: any, name?: string);
+
+  append_buffer(): void;
+  set_cursor(cursor: number): void;
+  get_buffer(): any;
+  generate_hash(): void;
+  get_block(index: number): Block | undefined;
+  add_tx(instruction: any): void;
+  mine(vm: any, no_curs?: boolean): Block;
+  add_block(block: Block): void;
+  get_latest_block(): Block | undefined;
+  stringify(str?: boolean): string | Record<string, any>;
+  add_chain(name: string): Chain;
+}
+
+export default Chain;

package/types/Explorer.d.ts

@@ -0,0 +1,9 @@
+declare class Explorer {
+  constructor();
+
+  chain_props: string[];
+
+  explore(query: string): any;
+}
+
+export default Explorer;

package/types/Filesystem.d.ts

@@ -0,0 +1,23 @@
+declare class Filesystem {
+  base_address: string;
+  physical_address: string;
+  name: string;
+  hash: string;
+  account: any;
+  manager: any;
+
+  constructor();
+
+  parse_path(path: string): any;
+  read(datapath: string): any;
+  save(content: any, chain: any, just_obj?: boolean): string | object;
+  data_addr(type: string): string;
+  get_type(chain: any): string;
+  write(arg: any, context: any): void;
+  name_hash(): void;
+  set_paths(chain: any): void;
+  add_chain(name: string, parent: any): any;
+  account_chain(account: any): any;
+}
+
+export default Filesystem;

package/types/Frame.d.ts

@@ -0,0 +1,14 @@
+declare class Frame {
+  parent: Frame | null;
+  object: any;
+  children: Frame[];
+  instructions: (string | Frame)[];
+
+  constructor(object: any, parent?: Frame | null);
+
+  frame(object: any): Frame;
+  to_instruction(): void;
+  flatten_instructions(): string[];
+}
+
+export default Frame;

package/types/Manager.d.ts

@@ -0,0 +1,21 @@
+import Account from "./Account";
+import Blockweb from "./Blockweb";
+import Oracle from "./Oracle";
+
+declare class Manager {
+  accounts: { [key: string]: Account };
+  running: number;
+  tracks: { [key: string]: any };
+  web: Blockweb;
+  oracle: Oracle;
+  clock: NodeJS.Timeout | null;
+
+  constructor();
+
+  start_clock(): void;
+  get_account(name: string): Account | undefined;
+  add_account(name: string, meta?: { private?: boolean }): Account;
+  push(program: { sequence: string[]; account: Account; pid: string }): void;
+}
+
+export default Manager;

package/types/Opcodes.d.ts

@@ -0,0 +1,11 @@
+declare class Opcodes {
+  opcodes: { [key: string]: (args?: any) => any };
+
+  constructor();
+
+  set(opcode: string, circuit: (args?: any) => any): void;
+  prepare_operation(opcode: string, context: any): void;
+  stdin(object: any, cb?: () => void): void;
+}
+
+export default Opcodes;

package/types/Oracle.d.ts

@@ -0,0 +1,17 @@
+import fs from "fs";
+
+declare class Oracle {
+  fs: typeof fs;
+  mgr: any;
+  datapaths: { [key: string]: { type: string; obj: any } };
+
+  constructor(mgr: any);
+
+  set(path: string, data: { type: string; obj: any }): void;
+
+  get(path: string): { type: string; obj: any } | undefined;
+
+  write(addr: string, data: any, meta?: { encoding: string }): void;
+}
+
+export default Oracle;

package/types/Virtual_machine.d.ts

@@ -0,0 +1,20 @@
+import Opcodes from "./Opcodes";
+
+declare class Virtual_machine extends Opcodes {
+  account: any;
+  contexts: any[];
+  stack: any[];
+  track: any;
+
+  constructor(context: any);
+
+  get_context(index?: number): any;
+
+  parse_arg(arg: string, is_cursor: boolean): any;
+
+  split_instruction(instruction: string): { opcode: string; args: string };
+
+  execute(instruction: string, track: any): void;
+}
+
+export default Virtual_machine;

package/types/index.d.ts

@@ -0,0 +1,4 @@
+export { default as Account } from "./Account";
+export { default as Virtual_machine } from "./Virtual_machine";
+export { default as Filesystem } from "./Filesystem";
+export { default as Loader_sequence } from "./Loader_sequence";