godprotocol 1.1.0 → 1.1.2

package/framer.js

@@ -1,124 +0,0 @@
-import Frame from "./Objects/Frame";
-
-let obj = {
-  Opcodes: {
-    add: null,
-    equal: null,
-    multiply: null,
-    subtract: null,
-    divide: null,
-    exp: null,
-    equal: null,
-
-    send: null,
-    readonly: null,
-    socket_send: null,
-
-    jmp: null,
-
-    stdout: null,
-    stdin: 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,
-    },
-    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__'}},
-    },
-    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})
-  }
-
-  
-};
-
-export default framer;
-export { obj };

package/opcodes/add.js

@@ -1,15 +0,0 @@
-let ops = [
-  { name: "add", sign: "+" },
-  { name: "multiply", sign: "*" },
-  { name: "subtract", sign: "-" },
-  { name: "divide", sign: "/" },
-  { name: "exp", 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,82 +0,0 @@
-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];
-
-  if (Array.isArray(base)) return base.slice(args.op1)[0];
-
-  return base[args.op1];
-};
-
-const setter = (args, vm) => {
-  let base = args.op0;
-  
-  if (typeof base === "number") return base;
-
-  if(vm.is_readonly(args))return;
-
-  if (typeof base === "string") {
-    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.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;
-};
-
-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

@@ -1,16 +0,0 @@
-const jmp = (args, vm, meta) => {
-  meta = meta || {};
-  let { flag, inverse } = meta;
-
-  let condition;
-  if (flag) condition = vm.flags[flag];
-  if (inverse) condition = !!!condition;
-
-  if ((condition || !flag) && typeof args.op0 === "number") {
-    vm.track.pointer = args.op0;
-
-    vm.pop_context()
-  }
-};
-
-export { jmp };

package/opcodes/std.js

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

package/opcodes.js

@@ -1,96 +0,0 @@
-// import { socket_send } from "./Socket";
-import callables from "./callables";
-import { ops } from "./opcodes/add";
-import { del, getter, setter, slice } from "./opcodes/indices";
-import { jmp } from "./opcodes/jmp";
-import { stdout } from "./opcodes/std";
-import { post_request } from "./utils/services";
-
-const opcodes = (account) => {
-  callables(account)
-
-  let set = account.vm.set;
-
-  ops.map((op) => {
-    if(op.jmp){
-      let flag = op.name
-      account.vm.flags[flag] = false
-      
-      set(`jmp_${flag}`, (args, vm) => jmp(args, vm, { flag }));
-      set(`jmp_not_${flag}`, (args, vm) =>
-        jmp(args, vm, { flag, inverse: true })
-    );
-    }
-    
-      set(op.name, (args) => {
-        if (!args) return;
-        try {
-          let {op0, op1}=args;
-          
-          let type0 = op0.type
-          let type1 = op1.type
-
-          let val0 = op0.static_value;
-          let val1 = op1.static_value;
-
-          if(op.name ==='divide' && val1 === 0){
-            return account.vm.stderr({name:'Zero_division_error', message: 'Do not divide by zero'})
-          }
-
-          let result = eval(`val0 ${op.sign} val1`);
-
-          if (op.jmp) {
-            result = !!result;
-            account.vm.flags[op.name] = result;
-          }
-          
-          return result;
-        } catch (e) {
-          console.log("opcodes: ", e.message);
-          console.log(e)
-        }
-      });
-  });
-
-  Object.keys(account.vm.flags).map((flag) => {
-    set(`jmp_${flag}`, (args, vm) => jmp(args, vm, { flag }));
-    set(`jmp_not_${flag}`, (args, vm) =>
-      jmp(args, vm, { flag, inverse: true })
-    );
-  });
-  set("jmp", jmp);
-
-  // Indices
-  set("setter", setter);
-  set("getter", getter);
-  set("del", del);
-  set("slice", slice);
-
-  set("send", (data) => post_request(data, account.vm.stdin));
-  // set("socket_send", socket_send);
-
-  set("stdout", stdout);
-  set("stdin",args=>account. vm.stdin(args&&args.op0));
-
-  /* Aliases */
-  set('quit', account.vm.quit)
-  set('exit', account.vm.quit)
-  
-  set('ret', arg=>account.vm.quit(arg, 'ret'))
-  
-  set('exec', account.vm.exec)
-
-  set('config', account.vm.set_config)
-
-  set("add_server", (args) => account.add_server(args && args.op0));
-
-  ["run", "load", "parse"].map((op) =>
-    set(op, (arg) => arg && arg.op0 && account.manager.endpoint(op, arg && arg.op0))
-  );
-
-  set("add_account", (arg) =>
-   account. manager.add_account({ ...arg.op0, string: true })
-  );
-};
-
-export default opcodes;

package/readme.md

@@ -1,133 +0,0 @@
-# God Protocol
-
-### A data mediator
-
-## Installation
-
-```
-npm install godprotocol --save
-```
-
-### Brief Description
-
-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.
-
-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(`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` | 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. |
-|              | 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.                                                                                                                                     |
-
-## Parse Result
-
-The parse is technically the third of the pipeline. It takes like parameters as the `run` method.
-
-### Usage
-
-It is used to retrieve blocks and chains, and also extract their properties.
-
-```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)                                                                              |
-|              | 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/godprotocol4/GodProtocol) for more details.
-
-[npm-url]: https://npmjs.org/package/godprotocol
-[downloads-url]: https://npmjs.org/package/godprotocol
-
-## References
-
-The main website for communicating updates and tutorials about the platform.
-[https://godprotocol-web.vercel.app](https://godprotocol-web.vercel.app)
-Physical Address - Token logical address from an High-level construct. Find everything else to know about it in the links below.
-[https://godprotocol-web.vercel.app/physical_address](https://godprotocol-web.vercel.app/physical_address)
-Explorer - Every blockchain technology has an explorer, learn more about ours.
-[https://godprotocol-web.vercel.app/explorer](https://godprotocol-web.vercel.app/explorer)
-Loader Sequence - Instruction bits, the lowest granular layer where a user can outline the execution flow.
-[https://godprotocol-web.vercel.app/loader_sequence](https://godprotocol-web.vercel.app/loader_sequence)

package/starter_scripts/constants.seq

@@ -1,11 +0,0 @@
-@/CONSTANTS
-./types
->instance 'instance'
->function 'function'
->boolean 'boolean'
->number 'number'
->string 'string'
->array 'array'
->twain 'twain'
-;
-;

package/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "compilerOptions": {
-    "baseUrl": ".",
-    "paths": {
-      "@types/*": ["types/*"]
-    }
-  }
-}

package/types/Account.d.ts

@@ -1,73 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

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

package/types/Filesystem.d.ts

@@ -1,23 +0,0 @@
-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;