godprotocol 1.0.3 → 1.0.5

package/.github/workflows/npm-publish-github-packages.yml

@@ -0,0 +1,36 @@
+# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
+# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
+
+name: Node.js Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+      - run: npm ci
+      - run: npm test
+
+  publish-gpr:
+    needs: build
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+          registry-url: https://npm.pkg.github.com/
+      - run: npm ci
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}

package/Datatypes/Array.js

@@ -1,4 +1,5 @@
-import { fs_buffer, hash, store } from "../utils/hash";
+import fs from "fs";
+import { hash, load } from "../utils/hash";
 
 class Arr {
   constructor(object, account) {
@@ -6,51 +7,26 @@ class Arr {
     this.account = account;
   }
 
-  store = (obj) => {
-    return store(obj, this.account);
-  };
-
-  persistent_load = (initiator) => {
-    let sequence = [
-      `link ${initiator.path}/Opcodes/${this.account}`,
-      `link ${initiator.path}/Datatypes/Array`,
-      "timestep value",
-    ];
-    this.object.map((o, i) => {
-      store(o, this.account, initiator);
-      sequence.push(`write {pending_children:-${i + 1}}`);
+  load = () => {
+    let obj = [];
+    this.object.map((o) => {
+      let blk = this.account.vm.web.blocks[o];
+      obj.push(load(blk.read_metadata()));
     });
-    sequence.push(
-      ...[
-        "mine",
-        "pop_link",
-        "history -1",
-        "timestep output",
-        "write {pending_children:-1}",
-        "mine",
-        "pop_link",
-      ]
-    );
-
-    initiator.load(sequence);
-
-    return this.object;
+    return obj;
   };
 
-  load = (initiator) => {
-    if (initiator) return this.persistent_load(initiator);
+  store = () => {
+    let curr_hash = hash("[]");
+    this.object.map((o) => {
+      hash(curr_hash + hash(o));
+    });
+    this.path = `${this.account.path}/Datatypes/Array`;
+    curr_hash = hash(curr_hash);
 
-    let arr = [];
-    for (let a = 0; a < this.object.length; a++) {
-      let item = this.object[a];
-      arr.push(this.store(item));
-    }
-    let addr = `${this.account.path}/Datatypes/Array/${hash(
-      JSON.stringify(arr)
-    )}`;
-    fs_buffer({ addr, data: arr });
+    fs.writeFileSync(`${this.path}/${curr_hash}`, JSON.stringify(this.object));
 
-    return addr;
+    return this;
   };
 }
 

package/Datatypes/Number.js

@@ -1,37 +1,20 @@
-import { fs_buffer } from "../utils/hash";
+import fs from "fs";
 
 class Num {
   constructor(object, account) {
-    this.object = object;
+    this.object = Number(object.join(""));
     this.account = account;
+    this.path = `${this.account.path}/Datatypes/Number/${this.object}`;
   }
 
-  load = (initiator) => {
-    initiator.load([
-      `link ${initiator.path}/Opcodes/${this.account}`,
-      `link ${initiator.path}/Datatypes/Number`,
-      "timestep value",
-      `write ${this.object}`,
-      "mine",
-      "pop_link",
-      "history -1",
-      "timestep output",
-      "write {pending_children:-1}",
-      "mine",
-      "pop_link",
-    ]);
-
-    return this.object;
+  load = () => {
+    return this;
   };
 
-  store = (initiator) => {
-    if (initiator) return this.load(initiator);
-
-    let addr = `${this.account.path}/Datatypes/Number/${this.object}`;
-
-    fs_buffer({ addr, data: { type: "number", value: this.object } });
+  store = () => {
+    fs.writeFileSync(this.path, this.object.toString());
 
-    return addr;
+    return this;
   };
 }
 

package/Datatypes/String.js

@@ -3,38 +3,20 @@ import { fs_buffer, hash } from "../utils/hash";
 
 class Str {
   constructor(object, account) {
-    this.object = object;
+    this.object = object.join("");
+    this.hash = hash(this.object);
     this.account = account;
   }
 
-  load = (initiator) => {
-    initiator.load([
-      `link ${initiator.path}/Opcodes/${this.account}`,
-      `link ${initiator.path}/Datatypes/String`,
-      "timestep value",
-      `write ${this.object}`,
-      "mine",
-      "pop_link",
-      "history -1",
-      "timestep output",
-      "write {pending_children:-1}",
-      "mine",
-      "pop_link",
-    ]);
-
-    return this.object;
+  load = () => {
+    return this;
   };
 
-  store = (initiator) => {
-    if (initiator) return this.load(initiator);
-
-    let addr = `${this.account.path}/Datatypes/String/${hash(
-      this.object || "[blank]"
-    )}`;
-
-    fs_buffer({ addr, data: { type: "string", value: this.object } });
+  store = () => {
+    this.path = `${this.account.path}/Datatypes/String/${this.hash}`;
+    fs.writeFileSync(this.path, this.object);
 
-    return addr;
+    return this;
   };
 }
 

package/Datatypes/Twain.js

@@ -1,4 +1,6 @@
-import { fs_buffer, hash, store } from "../utils/hash";
+import fs from "fs";
+import { hash } from "../utils/hash";
+import Arr from "./Array";
 
 class Twain {
   constructor(object, account) {
@@ -6,60 +8,30 @@ class Twain {
     this.account = account;
   }
 
-  store = (obj) => {
-    return store(obj, this.account);
-  };
-
-  persistent_load = (initiator) => {
-    let sequence = [
-      `link ${initiator.path}/Opcodes/${this.account}`,
-      `link ${initiator.path}/Datatypes/Twain`,
-    ];
-    for (let prop in this.object) {
-      let value = this.object[prop];
-      sequence.push(`timestep prop`);
-      let prop_addr = store(prop, this.account, initiator);
-      sequence.push(`write {pending_children:-1}`);
-      sequence.push(`timestep value`);
-      let value_addr = store(value, this.account, initiator);
-      sequence.push(`write {pending_children:-1}`);
-      obj[prop_addr] = value_addr;
-    }
-    sequence.push(
-      ...[
-        "mine",
-        "pop_link",
-        "history -1",
-        "timestep output",
-        "write {pending_children:-1}",
-        "mine",
-        "pop_link",
-      ]
-    );
-
-    initiator.load(sequence);
-
-    return this.object;
+  load = () => {
+    let obj = {};
+    this.object.map((o) => {
+      let blk = this.account.vm.web.blocks[o];
+      let pair = load(blk.read_metadata());
+      if (!(pair instanceof Arr))
+        return console.log("Something aint right in Twain.load");
+
+      obj[pair.object[0]] = obj[pair.object[1]];
+    });
+    return obj;
   };
 
-  load = (initiator) => {
-    if (initiator) return this.persistent_load();
-
-    let obj = {};
-    for (let prop in this.object) {
-      let value = this.object[prop];
-      let prop_addr = this.store(prop);
-      let value_addr = this.store(value);
-      obj[prop_addr] = value_addr;
-    }
-    let addr = `${this.account.path}/Datatypes/Twain/${hash(
-      JSON.stringify(obj)
-    )}`;
-    this.address = addr;
+  store = () => {
+    let curr_hash = hash("{}");
+    this.object.map((o) => {
+      hash(curr_hash + hash(o));
+    });
+    this.path = `${this.account.path}/Datatypes/Twain`;
+    curr_hash = hash(curr_hash);
 
-    fs_buffer({ addr, data: obj });
+    fs.writeFileSync(`${this.path}/${curr_hash}`, this.stringify());
 
-    return addr;
+    return this;
   };
 
   stringify = () => {

package/Index.js

@@ -1,54 +1,32 @@
-import http from "http";
-
 import Account from "./Objects/Account";
 import framer from "./framer";
 import opcodes from "./opcodes";
 import Socket_server from "./Socket";
 import { manage_key_pair } from "./utils/gen_key_pair";
+import create_server, { PORT } from "./utils/create_server";
 
 manage_key_pair();
 
-let PORT = 1900;
-
 const initiator = new Account(process.env.PUBLIC_KEY);
-let server = process.env.SERVER;
+let cli_server = process.env.SERVER;
 
-if (server) {
-  initiator.add_server(server);
+if (cli_server) {
+  initiator.add_server(cli_server);
 } else {
-  console.warn("set SERVER in your env.");
-  server = `http://localhost:${PORT}`;
-  initiator.add_server(server);
+  // console.warn("set SERVER in your env.");
+  cli_server = `http://localhost:${PORT}`;
+  initiator.add_server(cli_server);
 }
 
 framer(initiator);
 
 opcodes(initiator);
 
-http
-  .createServer((req, res) => {
-    let data = "";
-
-    req.on("data", (chunk) => {
-      data += chunk;
-    });
-    req.on("end", () => {
-      if (req.url === "/create_account") {
-        console.log(data);
-        initiator.account(data);
-      } else {
-        initiator.load(data);
-      }
-
-      res.end();
-    });
-  })
-  .listen(PORT);
+let instructions = ["cursor value", "write 7"];
+initiator.load({ instructions: ["add"] });
+
+create_server(initiator);
 
 Socket_server();
 
 export { initiator };
-
-console.log(
-  `\n...GOD PROTOCOL RUNNING :${PORT}\nYour Public_key: ${process.env.PUBLIC_KEY}`
-);

package/Objects/Account.js

@@ -1,10 +1,11 @@
-import { Blockchain } from "./Blockchain";
+import { Chain } from "./Blockchain";
 import Virtual_machine from "./Virtual_machine";
 import fs from "fs";
 import Emitter from "./Emitter";
 import Folder from "./folder";
 import Frame from "./Frame";
 import File from "./file";
+import { hash } from "../utils/hash";
 
 let emitter = new Emitter();
 
@@ -23,15 +24,17 @@ class Account {
     });
     this.account = this;
 
-    this.chain = new Blockchain(this);
+    this.chain = new Chain(this);
     this.vm = new Virtual_machine(this.chain);
     this.accounts = new Object();
 
     this.servers = new Array();
+    this.parents = new Array();
 
     this.column = 0;
     this.folders = new Array();
     this.files = new Array();
+    this.content_buffer = new Array();
   }
 
   add_server = (server) => {
@@ -46,26 +49,27 @@ class Account {
     this.column = value;
   };
 
-  get_active_file = () => {
-    let par = this.vm.get_context().hash;
-
-    let file = this.files.find((f) => f.name === par);
+  file = (name) => {
+    let file = this.files.find((f) => f.name === name);
 
     if (!file) {
-      file = new File(par, this);
+      file = new File(name, this);
       this.files.push(file);
-      this.active_file = file;
     }
 
     return file;
   };
 
-  folder = (name) => {
-    let folder = new Folder(name, this);
-    folder.account = this;
-    this.folders.push(folder);
+  folder = (name, context) => {
+    let name_hash = hash(name + context.hash);
+    let folder = this.folders.find((f) => f.hash === name_hash);
+    if (!folder) {
+      folder = new Folder(name, this, name_hash);
+      folder.account = this.account;
 
-    folder.context = this.vm.get_context();
+      this.folders.push(folder);
+    }
+    folder.context = context.hash;
 
     return folder;
   };
@@ -77,7 +81,8 @@ class Account {
   frame = (struct) => {
     let frame = new Frame(struct);
     frame.to_instruction();
-    frame.load(this);
+
+    return frame;
   };
 
   load = ({ instructions, account }) => {
@@ -112,14 +117,17 @@ class Account {
     return account;
   };
 
-  account = ({ public_key, server }) => {
+  create_account = ({ public_key, server }) => {
     let account = this.accounts[public_key];
     if (!account) {
       account = new Account(public_key);
 
       this.accounts[account.name] = account;
     }
-    !account.server.includes(server) && account.server.push(server);
+    !account.servers.includes(server) && account.servers.push(server);
+
+    !account.parents.find((p) => p.name === this.name) &&
+      account.parents.push(this);
 
     return account;
   };

package/Objects/Blockchain.js

@@ -1,17 +1,18 @@
+import fs from "fs";
 import Explorer from "./Explorer";
 import Twain from "../Datatypes/Twain";
-import { fs_buffer, hash } from "../utils/hash";
+import { hash } from "../utils/hash";
 
 class Block {
-  constructor(index, chain, data, previous_hash = "") {
-    this.index = index;
+  constructor(chain) {
+    this.index = chain.blocks.length;
     this.timestamp = Date.now();
-    this.data = data;
-    this.previous_hash = previous_hash;
+    this.data = chain.txs;
     this.chain = chain;
     this.parents = new Array();
     this.children = new Array();
-    this.path = `${this.chain.path}:${this.index}`;
+    this.hash = hash(hash(JSON.stringify(this.data)) + this.chain.hash);
+    this.path = `${this.chain.path}/${this.hash}`;
 
     this.column = 0;
   }
@@ -29,30 +30,32 @@ class Block {
   };
 
   calculate_hash() {
-    return hash(`${JSON.stringify(this.data)}`);
+    return this.hash;
   }
 
-  stringify = (not_twained) => {
+  read_metadata = (path) => {
+    let res = "";
+    try {
+      res = JSON.parse(fs.readFileSync(path, { encoding: "utf-8" }));
+    } catch (e) {
+      console.log(e.message);
+    }
+    return res;
+  };
+
+  stringify = (str) => {
     let obj = {
       index: this.index,
       hash: this.hash,
       previous_hash: this.previous_hash,
-      chain: this.chain.address,
+      chain: this.chain.hash,
     };
-    if (not_twained) {
-    }
-
-    let twain = new Twain(obj, this.chain.parent.account);
-    twain.load();
 
-    return {
-      type: "twain",
-      path: twain.address,
-    };
+    return str ? JSON.stringify(obj) : obj;
   };
 }
 
-class Blockchain extends Explorer {
+class Chain extends Explorer {
   constructor(parent, context) {
     super();
 
@@ -87,15 +90,15 @@ class Blockchain extends Explorer {
     return { type: "twain", path: twain.address };
   };
 
-  store = (block) => {
-    fs_buffer({ addr: block.address, data: block.stringify() });
+  store = (block, vm) => {
+    let metadata = this.parent.content_buffer;
 
-    fs_buffer({
-      addr: `${this.parent.account.path}/Objects/Blockchain/Blockchain/${this.hash}`,
-      data: this.stringify(),
-    });
+    let file = this.parent.file(block.hash);
+    file.content = metadata;
+    file.store(this.parent.account);
+    block.metadata = file.data_path;
 
-    block.file && block.file.store();
+    vm.web.new_block(block);
   };
 
   handle_children = (block) => {
@@ -103,25 +106,16 @@ class Blockchain extends Explorer {
     this.connections.push(block);
   };
 
-  mine = () => {
-    let blk = new Block(this.blocks.length, this, this.txs);
+  mine = (vm) => {
+    let blk = new Block(this);
 
     let latest_blk = this.get_latest_block();
     blk.previous_hash = latest_blk && latest_blk.hash;
-
-    blk.calculate_hash();
-
-    let active_file = this.parent.get_active_file();
-
-    blk.metadata = { content: active_file.contents.length };
     blk.timelapse = blk.timestamp - this.start_time;
 
-    blk.file = active_file;
-
     this.blocks.push(blk);
 
-    this.store(blk);
-    active_file.reset_content();
+    this.store(blk, vm);
 
     this.txs = new Array();
     this.pending_children = new Array();
@@ -138,4 +132,4 @@ class Blockchain extends Explorer {
   }
 }
 
-export { Blockchain, Block };
+export { Chain, Block };

package/Objects/Blockweb.js

@@ -1,11 +1,15 @@
-import { Blockchain } from "./Blockchain";
-
 class Blockweb {
   constructor(vm) {
     this.vm = vm;
     this.chains = new Object();
+    this.blocks = new Object();
   }
 
+  new_block = (block) => {
+    this.blocks[block.hash] = block;
+    this.chains[block.chain.hash] = block.chain;
+  };
+
   explore = (query) => {
     this.vm.get_context().chain.explore(query);
   };

package/Objects/Filesystem.js

@@ -1,7 +1,3 @@
-import { emitter } from "./God";
-import File from "./file";
-import Folder from "./folder";
-
 class File_system {
   constructor() {
     this.files = {};

package/Objects/Frame.js

@@ -1,9 +1,13 @@
+import { array_to_nested_objects } from "../utils/functions";
 import { Buffs, fs_buffer } from "../utils/hash";
 
 class Frame {
   constructor(object, parent) {
     this.parent = parent;
-    this.object = object;
+
+    this.object = Array.isArray(object)
+      ? array_to_nested_objects(object)
+      : object;
 
     this.children = new Array();
     this.instructions = new Array();
@@ -18,37 +22,15 @@ class Frame {
     return frame;
   };
 
-  load = (account) => {
-    account.load({ instructions: this.instructions });
-
-    setTimeout(() => {
-      while (Buffs.length) {
-        for (let b = 0; b < Buffs.length; b++) {
-          let buff = Buffs[b];
-          fs_buffer(buff.payload, b + 1);
-        }
-      }
-    }, 50);
-  };
-
   to_instruction = () => {
-    if (this.object.__type === "file") {
-    } else if (Array.isArray(this.object)) {
-      this.object.map((s) => this.frame(s).to_instruction());
-    } else if (["string", "number"].includes(typeof this.object)) {
-      this.instructions.push(`chain ${this.object}`);
-      this.instructions.push(`pop ${this.object}`);
-    } else
-      for (let prop in this.object) {
-        let val = this.object[prop];
-        this.instructions.push(`chain ${prop}`);
-
-        if (val) {
-          this.frame(val).to_instruction();
-        }
-
-        this.instructions.push(`pop ${prop}`);
-      }
+    for (let prop in this.object) {
+      let val = this.object[prop];
+      this.instructions.push(`chain ${prop}`);
+
+      val && this.frame(val).to_instruction();
+
+      this.instructions.push(`pop ${prop}`);
+    }
   };
 }
 

package/Objects/Opcodes.js

@@ -1,20 +1,28 @@
-import { store } from "../utils/hash";
+import Arr from "../Datatypes/Array";
+import Num from "../Datatypes/Number";
+import Str from "../Datatypes/String";
+import Twain from "../Datatypes/Twain";
 
 class Opcodes {
+  opcodes = new Object();
+
   set = (name, callable) => {
-    this[name] = callable;
+    this.opcodes[name] = callable;
   };
 
   prepare_operation = (opcode, context) => {
-    let path = `${context.parent.account.path}/Opcodes/${opcode}`;
-
-    let block = context.pending_children
-      .filter((blk) => blk.chain.parent.path === path)
-      .slice(-1)[0];
+    let circ = this.opcodes[opcode];
+    circ(context.parent.content_buffer, context);
+  };
 
-    let arg = block.file.activate_content(block.metadata.content);
+  parse_content = (buffer) => {
+    let obj;
+    if (buffer.type === "twain") obj = new Twain(buffer.value).load();
+    else if (buffer.type === "array") obj = new Arr(buffer.value).load();
+    else if (buffer.type === "string") obj = new Str(buffer.value).load();
+    else if (buffer.type === "number") obj = new Num(buffer.value).load();
 
-    store(this[opcode](arg, this), opcode, this.get_context(0).parent);
+    return obj;
   };
 }
 

package/Objects/Virtual_machine.js

@@ -1,7 +1,7 @@
 import { Block } from "./Blockchain";
 import Blockweb from "./Blockweb";
+import File_system from "./Filesystem";
 import Frame from "./Frame";
-import { emitter } from "./Account";
 import Opcodes from "./Opcodes";
 
 class Virtual_machine extends Opcodes {
@@ -10,9 +10,8 @@ class Virtual_machine extends Opcodes {
 
     this.state = [chain];
     this.web = new Blockweb(this);
+    this.fm = new File_system(this);
 
-    this.instruction_stack = new Array();
-    this.running = 0;
     this.pointers = new Array();
   }
 
@@ -25,15 +24,16 @@ class Virtual_machine extends Opcodes {
 
     while (this.pointers.slice(-1)[0] < instructions.length && !this.err_) {
       let ins = instructions[this.pointers.slice(-1)[0]];
-
-      let res = this.check_instruction(ins);
-      if (res) {
-      } else this.execute(ins);
+      if (ins) {
+        let res = this.check_instruction(ins);
+        if (res) {
+        } else this.execute(ins);
+      }
 
       this.pointers[this.pointers.length - 1] = this.pointers.slice(-1)[0] + 1;
     }
     this.pointers.pop();
-    this.get_context().mine();
+    this.get_context().mine(this);
   };
 
   check_instruction = (instruction) => {
@@ -50,40 +50,57 @@ class Virtual_machine extends Opcodes {
     return true;
   };
 
+  readonly = (tag) => {
+    let tags = tag.split(":");
+    tags[0] = tags[0].slice(1);
+    tags[1] = tags[1].slice(0, -1);
+
+    console.log(tags);
+  };
+
+  parse_arg = (arg) => {
+    let data;
+    if (!arg) return;
+    if (arg.startsWith("{")) {
+      data = this.readonly();
+    }
+
+    return data;
+  };
+
   execute(instruction) {
     let [opcode, args] = instruction.split(" ");
 
     let context = this.get_context();
 
     context.add_tx(instruction);
+    args = this.parse_arg(args);
+
     switch (opcode) {
       case "chain":
         let folder = context.parent.folder(args, context);
         this.state.push(folder.chain);
         break;
       case "link":
-        emitter.emit(args, {
-          action: "parse",
-          aft: (res) => this.state.push(res.chain),
-        });
+        this.state.push(args);
         break;
       case "mine":
-        context.mine();
+        context.mine(this);
         this.state.slice(-2)[0].handle_children(context.get_latest_block());
         break;
       case "pop_link":
         this.state.pop();
         break;
       case "pop":
-        context.mine();
+        context.mine(this);
         this.state.pop();
         break;
+      case "run":
+        this.push(args.data);
+        break;
       default:
-        if (["timestep", "history", "write"].includes(opcode)) {
-          context.parent.get_active_file()[opcode](args, context);
-        } else {
-          this.prepare_operation(opcode, context);
-        }
+        if (["cursor", "write"].includes(opcode)) context[opcode](args);
+        else this.prepare_operation(opcode, context);
     }
   }
 

package/Objects/file.js

@@ -1,212 +1,20 @@
-import fs from "fs";
-import Twain from "../Datatypes/Twain";
 import { store } from "../utils/hash";
 
 class File {
-  object_name = "File";
-
   constructor(name, folder) {
     this.name = name;
     this.parent = folder;
 
     this.path = `${this.parent.path}/${this.name}`;
 
-    this.contents = new Array();
     this.content = null;
-    this.set_path();
 
     this.frame_path = `${this.parent.account.path}/Objects/File`;
-
-    this.r = 0;
-    this.col = "0";
   }
 
-  activate_content = (index) => {
-    let content = this.contents[Number(index)];
-
-    let obj = {};
-    for (let prop in content) {
-      let value = content[prop];
-
-      obj[prop] = this.parse_content(value[0]);
-    }
-
-    return obj;
-  };
-
-  parse_content = (content) => {
-    if (content && content.includes && content.includes("/")) {
-      let res = this.parent.chain.connections.find((c, i) => {
-        return c.path === content;
-      });
-
-      let obj = this.datatypes(
-        res.file.activate_content(res.metadata.content),
-        res
-      );
-
-      return obj;
-    } else return content;
-  };
-
-  datatypes = (obj, block) => {
-    if (
-      block.chain.parent.path === `${this.parent.account.path}/Datatypes/Number`
-    ) {
-      return Number(obj.value);
-    } else if (
-      block.chain.parent.path === `${this.parent.account.path}/Datatypes/String`
-    ) {
-      return obj.value.toString();
-    }
-    return obj;
-  };
-
-  reset_content = () => {
-    if (this.content) {
-      if (this.r < 0) {
-        this.contents.splice(this.r, 1, this.content);
-      } else this.contents.push(this.content);
-    }
-    this.r = 0;
-    this.col = "0";
-
-    this.content = null;
-
-    this.parent.active_file = null;
-  };
-
-  get = (opcode) => {
-    return this[opcode];
-  };
-
-  timestep = (col) => {
-    this.col = col;
-  };
-
-  history = (r) => {
-    this.r = Number(r);
-    let content = this.contents.slice(r)[0];
-    this.content = content;
-  };
-
-  fetch_arg = (path) => {
-    let block = this.chain.explore({ parents: `${this.frame_path}/${path}` });
-    return block.file.parse(true);
-  };
-
-  readonly = (prop, index, context) => {
-    let initiator = context.get_context(0);
-    if (
-      [
-        "timelapse",
-        "timestamp",
-        "data",
-        "hash",
-        "path",
-        "children",
-        "parents",
-        "chain",
-      ].includes(prop)
-    ) {
-      let blk = context.pending_children.slice(index || 0)[0];
-      store(blk[prop], "readonly", initiator);
-    } else if (
-      [
-        "parent",
-        "context",
-        "name",
-        "hash",
-        "path",
-        "connections",
-        "pending_children",
-        "blocks",
-      ].includes(prop)
-    ) {
-      let value = context[prop];
-      if (index && Array.isArray(value)) value.slice(index)[0];
-      store(value, "readonly", initiator);
-    }
-
-    return `${initiator.path}/Opcodes/readonly:${
-      initiator.pending_children.slice(-1)[0].index
-    }`;
-  };
-
-  write = (data, context) => {
-    if (data.startsWith("{") && data.endsWith("}")) {
-      let offset = data.split(":");
-      let prop = data[0].slice(1);
-      let index = Number(offset[1].slice(0, -1));
-
-      data = this.readonly(prop, index, context);
-    }
-
-    if (!this.content) this.content = new Object();
-
-    let col = this.content[this.col];
-    if (!col) {
-      col = new Array();
-
-      this.content[this.col] = col;
-    }
-
-    if (!col.includes(data)) col.unshift(data);
-  };
-
-  read = (history) => {
-    let res = this.content[this.row];
-    if (this.col) res = res[this.col];
-
-    return history != null ? res[history] : res;
-  };
-
-  run = (args, vm) => {
-    let block = vm.web.explore({ name: args });
-
-    block.map((blk) => vm.push(blk));
-  };
-
-  parse = (content) => {
-    content = content || this.fetch_arg(`parse/content`);
-
-    let obj = content && this.content;
-    if (!obj) {
-      obj = this.stringify();
-    }
-
-    obj = new Twain(obj);
-
-    fs.writeFileSync(`${this.frame_path}/parse/output`, obj.stringify());
-
-    return obj;
-  };
-
   store = () => {
-    let str = "";
-    this.reset_content();
-
-    this.contents.map((c) => (str += `${JSON.stringify(c)}\n`));
-    fs.writeFileSync(this.path, str);
-  };
-
-  set_path = () => {
-    if (!fs.existsSync(this.path)) {
-      fs.writeFileSync(this.path, "");
-    } else {
-      this.existed = true;
-      let content = fs.readFileSync(this.path, { encoding: "utf-8" });
-      try {
-        content = content.split("\n").map((c) => JSON.parse(c));
-      } catch (e) {
-        content = [];
-      }
-      if (!Array.isArray(content)) {
-        content = [content];
-      }
-
-      this.contents = content;
-    }
+    this.content_object = store(this.content);
+    this.data_path = this.content_object && this.content_object.path;
   };
 }
 

package/Objects/folder.js

@@ -1,50 +1,42 @@
 import fs from "fs";
 import { emitter } from "./Account";
 import File from "./file";
-import { Blockchain } from "./Blockchain";
+import { Block, Chain } from "./Blockchain";
+import { hash } from "../utils/hash";
 
 class Folder {
   object_name = "folder";
 
-  constructor(name, parent) {
+  constructor(name, parent, hash) {
     this.name = name;
     this.parent = parent;
-    this.path = `${parent.path}/${this.name}`;
+    this.hash = hash;
+    this.path = `${parent.path}/${this.hash}`;
 
-    emitter.listen(this.path, (payload) => {
-      let { aft, bfr } = payload;
-
-      bfr && bfr(this, payload);
-
-      aft && aft(this);
-    });
+    emitter.listen(this.path, (cb) => cb && cb(this));
 
     this.active_file = null;
     this.files = new Array();
     this.folders = new Array();
-    this.chain = new Blockchain(this);
+    this.chain = new Chain(this);
+
+    this.curs = -1;
+    this.content_buffer = new Object();
 
     this.set_path();
   }
 
-  timestep = (col) => this.get_active_file().timestep(col);
-
-  history = (r) => this.get_active_file().history(r);
-
-  write = (data) => this.get_active_file().write(data);
-
-  get_active_file = () => {
-    let par = this.context.hash;
+  cursor = (curs) => (this.curs = curs);
 
-    let file = this.files.find((f) => f.name === par);
+  write = (data) => {
+    let v = this.content_buffer[this.curs];
 
-    if (!file) {
-      file = new File(par, this);
-      this.files.push(file);
-      this.active_file = file;
+    if (!v) {
+      v = new Array();
+      this.content_buffer[this.curs] = v;
     }
 
-    return file;
+    v.push(data instanceof Block ? data.hash : data);
   };
 
   file = (name) => {
@@ -53,9 +45,7 @@ class Folder {
     if (!file) {
       file = new File(name, this);
       this.files.push(file);
-    } else file.reset_content();
-
-    this.active_file = file;
+    }
 
     return file;
   };
@@ -76,14 +66,15 @@ class Folder {
   };
 
   folder = (name, context) => {
-    let folder = this.folders.find((f) => f.name === name);
+    let name_hash = hash(name + context.hash);
+    let folder = this.folders.find((f) => f.hash === name_hash);
     if (!folder) {
-      folder = new Folder(name, this);
+      folder = new Folder(name, this, name_hash);
       folder.account = this.account;
 
       this.folders.push(folder);
     }
-    folder.context = context;
+    folder.context = context.hash;
 
     return folder;
   };

package/Socket.js

@@ -8,6 +8,7 @@ let pendings = new Object();
 
 const Socket_server = () => {
   let server = net.createServer((socket) => {
+    console.log("meeeee");
     socket.on("connect", () => {
       Sockets[socket.id] = { socket };
       console.log(`New client connection - ${socket.id}`);

package/framer.js

@@ -1,5 +1,5 @@
 const framer = (initiator) => {
-  initiator.frame({
+  let frame = initiator.frame({
     Opcodes: {
       add: null,
       equal: null,
@@ -17,7 +17,7 @@ const framer = (initiator) => {
     },
     Objects: {
       Blockchain: {
-        Blockchain: null,
+        Chain: null,
         Block: null,
       },
       Folder: {
@@ -33,6 +33,8 @@ const framer = (initiator) => {
       },
     },
   });
+
+  initiator.load({ instructions: frame.instructions });
 };
 
 export default framer;

package/index.d.ts

@@ -21,7 +21,7 @@ export class Blockchain {
 }
 
 export class Block {
-  constructor(index: number, chain: Blockchain, data: string[]);
+  constructor(chain: Blockchain);
   get(prop: string): any;
 
   set(prop: string, value: any): null;

package/opcodes/add.js

@@ -2,9 +2,9 @@ import Num from "../Datatypes/Number";
 import { initiator } from "../Index";
 
 const add = (args) => {
-  let result = args.op1 + args.op2;
+  console.log(args);
 
-  return new Num(result, "add").load(initiator);
+  return;
 };
 
 const divide = (args) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "godprotocol",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "A data mediator.",
   "main": "Index.js",
   "types": "index.d.ts",
@@ -31,12 +31,9 @@
     "godprotocol"
   ],
   "dependencies": {
-    "body-parser": "^1.20.2",
     "crypto": "^1.0.1",
     "elliptic": "^6.5.5",
-    "express": "^4.19.2",
     "fs": "^0.0.1-security",
-    "net": "^1.0.2",
-    "semitter": "^1.2.1"
+    "net": "^1.0.2"
   }
 }

package/utils/create_server.js

@@ -0,0 +1,43 @@
+import http from "http";
+
+let PORT = 1900;
+
+const create_server = (initiator) => {
+  let server = http.createServer((req, res) => {
+    let data = "";
+
+    req.on("data", (chunk) => {
+      console.log("Received chunk");
+      data += chunk;
+    });
+
+    req.on("end", () => {
+      data = JSON.parse(data);
+      if (req.url === "/create_account" && req.method === "POST") {
+        initiator.create_account(data);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({ status: "success", message: "Account created" })
+        );
+      } else {
+        initiator.load(data);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ status: "success", message: "Data loaded" }));
+      }
+    });
+
+    req.on("error", (e) => {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "error", message: e.message }));
+    });
+  });
+
+  server.listen(PORT, () => {
+    console.log(
+      `\n...GOD PROTOCOL RUNNING :${PORT}\nYour Public_key: ${process.env.PUBLIC_KEY}`
+    );
+  });
+};
+
+export default create_server;
+export { PORT };

package/utils/functions.js

@@ -0,0 +1,8 @@
+const array_to_nested_objects = (arr) => {
+  if (arr.length === 0) return null;
+
+  let [first, ...rest] = arr;
+  return { [first]: array_to_nested_objects(rest) };
+};
+
+export { array_to_nested_objects };

package/utils/hash.js

@@ -6,7 +6,7 @@ import Twain from "../Datatypes/Twain";
 const crypto = require("crypto");
 
 const hash = (data) => {
-  let hash = crypto.createHash("sha512");
+  let hash = crypto.createHash("sha256");
 
   hash.update(data);
 
@@ -27,21 +27,24 @@ const fs_buffer = (payload, buff_index) => {
   }
 };
 
-const store = (obj, account, initiator) => {
+const store = (obj) => {
   let addr;
-  if (typeof obj === "number") {
-    addr = new Num(obj, account).store(initiator);
-  } else if (typeof obj === "string") {
-    addr = new Str(obj, account).store(initiator);
-  } else if (typeof obj === "object") {
-    if (Array.isArray(obj)) {
-      addr = new Arr(obj, account).load(initiator);
-    } else {
-      addr = new Twain(obj, account).load(initiator);
-    }
+
+  if (obj.type === "string") {
+    addr = new Str(obj.value.join("")).store();
+  } else if (obj.type === "number") {
+    addr = new Num(obj.value).store();
+  } else if (obj.type === "array") {
+    addr = new Arr(obj.value).store();
+  } else if (obj.type === "twain") {
+    addr = new Twain(obj.value).store();
   }
 
   return addr;
 };
 
-export { hash, fs_buffer, store, Buffs };
+const load = (addr) => {
+  let obj;
+};
+
+export { hash, fs_buffer, store, Buffs, load };