marsxchain 1.0.0

package/blockchain/index.js

@@ -0,0 +1,53 @@
+const Block = require('./block');
+
+class Blockchain {
+  constructor({ state }) {
+    this.chain = [Block.genesis()];
+    this.state = state;
+  }
+
+  addBlock({ block, transactionQueue }) {
+    return new Promise((resolve, reject) => {
+      Block.validateBlock({
+        lastBlock: this.chain[this.chain.length-1],
+        block,
+        state: this.state
+      }).then(() => {
+        this.chain.push(block);
+
+        Block.runBlock({ block, state: this.state });
+
+        transactionQueue.clearBlockTransactions({
+          transactionSeries: block.transactionSeries
+        });
+
+        return resolve();
+      }).catch(reject);
+    });
+  }
+
+  replaceChain({ chain }) {
+    return new Promise(async (resolve, reject) => {
+      for (let i=0; i<chain.length; i++) {
+        const block = chain[i];
+        const lastBlockIndex = i-1;
+        const lastBlock = lastBlockIndex >= 0 ? chain[i-1] : null;
+
+        try {
+          await Block.validateBlock({ lastBlock, block, state: this.state });
+          Block.runBlock({ block, state: this.state });
+        } catch (error) {
+          return reject(error);
+        }
+
+        console.log(`*-- Validated block number: ${block.blockHeaders.number}`);
+      }
+
+      this.chain = chain;
+
+      return resolve();
+    });
+  }
+}
+
+module.exports = Blockchain;

package/config.js

@@ -0,0 +1,27 @@
+const GENESIS_DATA = {
+  blockHeaders: {
+    parentHash: '--genesis-parent-hash--',
+    beneficiary: '--genesis-beneficiary--',
+    difficulty: 1,
+    number: 0,
+    timestamp: '--genesis-timestamp--',
+    nonce: 0,
+    transactionsRoot: '--genesis-transactions-root-',
+    stateRoot: '--genesis-state-root--'
+  },
+  transactionSeries: []
+};
+
+const MILLISECONDS = 1;
+const SECONDS = 1000 * MILLISECONDS;
+const MINE_RATE = 13 * SECONDS;
+
+const STARTING_BALANCE = 1000;
+const MINING_REWARD = 50;
+
+module.exports = {
+  GENESIS_DATA,
+  MINE_RATE,
+  STARTING_BALANCE,
+  MINING_REWARD
+};

package/interpreter/index.js

@@ -0,0 +1,251 @@
+const STOP = 'STOP';
+const ADD = 'ADD';
+const SUB = 'SUB';
+const MUL = 'MUL';
+const DIV = 'DIV';
+const PUSH = 'PUSH';
+const LT = 'LT';
+const GT = 'GT';
+const EQ = 'EQ';
+const AND = 'AND';
+const OR = 'OR';
+const JUMP = 'JUMP';
+const JUMPI = 'JUMPI';
+const STORE = 'STORE';
+const LOAD = 'LOAD';
+
+const OPCODE_MAP = {
+  STOP,
+  ADD,
+  SUB,
+  MUL,
+  DIV,
+  PUSH,
+  LT,
+  GT,
+  EQ,
+  AND,
+  OR,
+  JUMP,
+  JUMPI,
+  STORE,
+  LOAD
+};
+
+const OPCODE_GAS_MAP = {
+  STOP: 0,
+  ADD: 1,
+  SUB: 1,
+  MUL: 1,
+  DIV: 1,
+  PUSH: 0,
+  LT: 1,
+  GT: 1,
+  EQ: 1,
+  AND: 1,
+  OR: 1,
+  JUMP: 2,
+  JUMPI: 2,
+  STORE: 5,
+  LOAD: 5
+};
+
+const EXECUTION_COMPLETE = 'Execution complete';
+const EXECUTION_LIMIT = 10000;
+
+class Interpreter {
+  constructor({ storageTrie } = {}) {
+    this.state = {
+      programCounter: 0,
+      stack: [],
+      code: [],
+      executionCount: 0
+    };
+    this.storageTrie = storageTrie;
+  }
+
+  jump() {
+    const destination = this.state.stack.pop();
+
+    if (
+      destination < 0
+      || destination > this.state.code.length
+    ) {
+      throw new Error(`Invalid destination: ${destination}`);
+    }
+
+    this.state.programCounter = destination;
+    this.state.programCounter--;
+  }
+
+  runCode(code) {
+    this.state.code = code;
+
+    let gasUsed = 0;
+
+    while (this.state.programCounter < this.state.code.length) {
+      this.state.executionCount++;
+
+      if (this.state.executionCount > EXECUTION_LIMIT) {
+        throw new Error(
+          `Check for an infinite loop. Execution limit of ${EXECUTION_LIMIT} exceeded`
+        );
+      }
+
+      const opCode = this.state.code[this.state.programCounter];
+
+      gasUsed += OPCODE_GAS_MAP[opCode];
+
+      let value;
+      let key;
+
+      try {
+        switch (opCode) {
+          case STOP:
+            throw new Error(EXECUTION_COMPLETE);
+          case PUSH:
+            this.state.programCounter++;
+
+            if (this.state.programCounter === this.state.code.length) {
+              throw new Error(`The 'PUSH' instruction cannot be last.`);
+            }
+
+            value = this.state.code[this.state.programCounter];
+            this.state.stack.push(value);
+            break;
+          case ADD:
+          case SUB:
+          case MUL:
+          case DIV:
+          case LT:
+          case GT:
+          case EQ:
+          case AND:
+          case OR:
+            const a = this.state.stack.pop();
+            const b = this.state.stack.pop();
+
+            let result;
+
+            if (opCode === ADD) result = a + b;
+            if (opCode === SUB) result = a - b;
+            if (opCode === MUL) result = a * b;
+            if (opCode === DIV) result = a / b;
+            if (opCode === LT) result = a < b ? 1 : 0;
+            if (opCode === GT) result = a > b ? 1 : 0;
+            if (opCode === EQ) result = a === b ? 1 : 0;
+            if (opCode === AND) result = a && b;
+            if (opCode === OR) result = a || b;
+
+            this.state.stack.push(result);
+            break;
+          case JUMP:
+            this.jump();
+            break;
+          case JUMPI:
+            const condition = this.state.stack.pop();
+
+            if (condition === 1) {
+              this.jump();
+            }
+            break;
+          case STORE:
+            key = this.state.stack.pop();
+            value = this.state.stack.pop();
+
+            this.storageTrie.put({ key, value });
+
+            break;
+          case LOAD:
+            key = this.state.stack.pop();
+            value = this.storageTrie.get({ key });
+
+            this.state.stack.push(value);
+
+            break;
+          default:
+            break;
+        }
+      } catch (error) {
+        if (error.message === EXECUTION_COMPLETE) {
+          return {
+            result: this.state.stack[this.state.stack.length-1],
+            gasUsed
+          };
+        }
+
+        throw error;
+      }
+
+      this.state.programCounter++;
+    }
+  }
+}
+
+Interpreter.OPCODE_MAP = OPCODE_MAP;
+module.exports = Interpreter;
+
+// let code = [PUSH, 2, PUSH, 3, ADD, STOP];
+// let result = new Interpreter().runCode(code);
+// console.log('Result of 3 ADD 2:', result);
+
+// code = [PUSH, 2, PUSH, 3, SUB, STOP];
+// result = new Interpreter().runCode(code);
+// console.log('Result of 3 SUB 2:', result);
+
+// code = [PUSH, 2, PUSH, 3, MUL, STOP];
+// result = new Interpreter().runCode(code);
+// console.log('Result of 3 MUL 2:', result);
+
+// code = [PUSH, 2, PUSH, 3, DIV, STOP];
+// result = new Interpreter().runCode(code);
+// console.log('Result of 3 DIV 2:', result);
+
+// code = [PUSH, 2, PUSH, 3, LT, STOP];
+// result = new Interpreter().runCode(code);
+// console.log('Result of 3 LT 2:', result);
+
+// code = [PUSH, 2, PUSH, 3, GT, STOP];
+// result = new Interpreter().runCode(code);
+// console.log('Result of 3 GT 2:', result);
+
+// code = [PUSH, 2, PUSH, 2, EQ, STOP];
+// result = new Interpreter().runCode(code);
+// console.log('Result of 2 EQ 2:', result);
+
+// code = [PUSH, 1, PUSH, 0, AND, STOP];
+// result = new Interpreter().runCode(code);
+// console.log('Result of 0 AND 1:', result);
+
+// code = [PUSH, 1, PUSH, 0, OR, STOP];
+// result = new Interpreter().runCode(code);
+// console.log('Result of 0 OR 1:', result);
+
+// code = [PUSH, 6, JUMP, PUSH, 0, JUMP, PUSH, 'jump successful', STOP];
+// result = new Interpreter().runCode(code);
+// console.log('Result of JUMP:', result);
+
+// code = [PUSH, 8, PUSH, 1, JUMPI, PUSH, 0, JUMP, PUSH, 'jump successful', STOP];
+// result = new Interpreter().runCode(code);
+// console.log('Result of JUMPI:', result);
+
+// code = [PUSH, 99, JUMP, PUSH, 0, JUMP, PUSH, 'jump successful', STOP];
+// try {
+//   new Interpreter().runCode(code);
+// } catch (error) {
+//   console.log('Invalid destination error:', error.message);
+// }
+
+// code = [PUSH, 0, PUSH];
+// try {
+//   new Interpreter().runCode(code);
+// } catch (error) {
+//   console.log('Expected invalid PUSH error:', error.message);
+// }
+
+// code = [PUSH, 0, JUMP, STOP];
+// try {
+//   new Interpreter().runCode(code);
+// } catch (error) {
+//   console.log('Expected invalid execution error:', error.message);
+// }

package/interpreter/index.test.js

@@ -0,0 +1,167 @@
+const Interpreter = require('./index');
+const Trie = require('../store/trie');
+const {
+  STOP,
+  ADD,
+  SUB,
+  MUL,
+  DIV,
+  PUSH,
+  LT,
+  GT,
+  EQ,
+  AND,
+  OR,
+  JUMP,
+  JUMPI,
+  STORE,
+  LOAD
+} = Interpreter.OPCODE_MAP;
+
+describe('Interpreter', () => {
+  describe('runCode()', () => {
+    describe('and the code inludes ADD', () => {
+      it('adds two values', () => {
+        expect(
+          new Interpreter().runCode([PUSH, 2, PUSH, 3, ADD, STOP]).result
+        ).toEqual(5);
+      });
+    });
+
+    describe('and the code inludes SUB', () => {
+      it('subtracts one value from another', () => {
+        expect(
+          new Interpreter().runCode([PUSH, 2, PUSH, 3, SUB, STOP]).result
+        ).toEqual(1);
+      });
+    });
+
+    describe('and the code inludes MUL', () => {
+      it('products two values', () => {
+        expect(
+          new Interpreter().runCode([PUSH, 2, PUSH, 3, MUL, STOP]).result
+        ).toEqual(6);
+      });
+    });
+
+    describe('and the code inludes DIV', () => {
+      it('divides one value from another', () => {
+        expect(
+          new Interpreter().runCode([PUSH, 2, PUSH, 3, DIV, STOP]).result
+        ).toEqual(1.5);
+      });
+    });
+
+    describe('and the code inludes LT', () => {
+      it('checks if one value is less than another', () => {
+        expect(
+          new Interpreter().runCode([PUSH, 2, PUSH, 3, LT, STOP]).result
+        ).toEqual(0);
+      });
+    });
+
+    describe('and the code inludes GT', () => {
+      it('checks if one value is greater than another', () => {
+        expect(
+          new Interpreter().runCode([PUSH, 2, PUSH, 3, GT, STOP]).result
+        ).toEqual(1);
+      });
+    });
+
+    describe('and the code inludes EQ', () => {
+      it('checks if one value is equal to another', () => {
+        expect(
+          new Interpreter().runCode([PUSH, 2, PUSH, 3, EQ, STOP]).result
+        ).toEqual(0);
+      });
+    });
+
+    describe('and the code inludes AND', () => {
+      it('ands two conditions', () => {
+        expect(
+          new Interpreter().runCode([PUSH, 1, PUSH, 0, AND, STOP]).result
+        ).toEqual(0);
+      });
+    });
+
+    describe('and the code inludes OR', () => {
+      it('ors two conditions', () => {
+        expect(
+          new Interpreter().runCode([PUSH, 1, PUSH, 0, OR, STOP]).result
+        ).toEqual(1);
+      });
+    });
+
+    describe('and the code inludes JUMP', () => {
+      it('jumps to a destination', () => {
+        expect(
+          new Interpreter().runCode(
+            [PUSH, 6, JUMP, PUSH, 0, JUMP, PUSH, 'jump successful', STOP]
+          ).result
+        ).toEqual('jump successful');
+      });
+    });
+
+    describe('and the code inludes JUMPI', () => {
+      it('jumps to a destination', () => {
+        expect(
+          new Interpreter().runCode(
+            [PUSH, 8, PUSH, 1, JUMPI, PUSH, 0, JUMP, PUSH, 'jump successful', STOP]
+          ).result
+        ).toEqual('jump successful');
+      });
+    });
+
+    describe('and the code includes STORE', () => {
+      const interpreter = new Interpreter({
+        storageTrie: new Trie()
+      });
+      const key = 'foo';
+      const value = 'bar';
+
+      interpreter.runCode([PUSH, value, PUSH, key, STORE, STOP]);
+
+      expect(interpreter.storageTrie.get({ key })).toEqual(value);
+    });
+
+    describe('and the code includes LOAD', () => {
+      const interpreter = new Interpreter({
+        storageTrie: new Trie()
+      });
+      const key = 'foo';
+      const value = 'bar';
+
+      expect(
+        interpreter.runCode(
+          [PUSH, value, PUSH, key, STORE, PUSH, key, LOAD, STOP]
+        ).result
+      ).toEqual(value);
+    });
+
+    describe('and the code includes an invalid JUMP destination', () => {
+      it('throws an error', () => {
+        expect(
+          () => new Interpreter().runCode(
+            [PUSH, 99, JUMP, PUSH, 0, JUMP, PUSH, 'jump successful', STOP]
+          )
+        ).toThrow('Invalid destination: 99');
+      });
+    });
+
+    describe('and the code includes an invalid PUSH value', () => {
+      it('throws an error', () => {
+        expect(
+          () => new Interpreter().runCode([PUSH, 0, PUSH])
+        ).toThrow("The 'PUSH' instruction cannot be last.");
+      });
+    });
+
+    describe('and the code includes an infinite loop', () => {
+      it('throws an error', () => {
+        expect(
+          () => new Interpreter().runCode([PUSH, 0, JUMP, STOP])
+        ).toThrow('Check for an infinite loop. Execution limit of 10000 exceeded');
+      });
+    });
+  });
+});

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "marsxchain",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "api-test": "node ./api-test.js",
+    "dev": "nodemon ./api",
+    "dev-peer": "nodemon ./api --peer",
+    "start": "node ./api",
+    "test": "jest --watchAll"
+  },
+  "jest": {
+    "testEnvironment": "node"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LifeCoachRay/SmartChain"
+  },
+  "keywords": [],
+  "author": "Life Coach Ray",
+  "license": "GNU",
+  "bugs": {
+    "url": "https://github.com/LifeCoachRay/SmartChain"
+  },
+  "homepage": "https://github.com/LifeCoachRay/SmartChain/blob/main/README.md",
+  "dependencies": {
+    "body-parser": "^1.20.0",
+    "elliptic": "^6.5.4",
+    "express": "^4.18.1",
+    "git": "^0.1.5",
+    "index.js": "^0.0.3",
+    "jest": "^24.9.0",
+    "js-sha3": "^0.8.0",
+    "lodash": "^4.17.21",
+    "node": "^18.7.0",
+    "pubnub": "^4.37.0",
+    "request": "^2.88.2",
+    "uuid": "^3.4.0"
+  },
+  "devDependencies": {
+    "nodemon": "^1.19.4"
+  }
+}

package/store/state.js

@@ -0,0 +1,32 @@
+const Trie = require('./trie');
+
+class State {
+  constructor() {
+    this.stateTrie = new Trie();
+    this.storageTrieMap = {};
+  }
+
+  putAccount({ address, accountData }) {
+    if (!this.storageTrieMap[address]) {
+      this.storageTrieMap[address] = new Trie();
+    }
+
+    this.stateTrie.put({
+      key: address,
+      value: {
+        ...accountData,
+        storageRoot: this.storageTrieMap[address].rootHash
+      }
+    });
+  }
+
+  getAccount({ address }) {
+    return this.stateTrie.get({ key: address });
+  }
+
+  getStateRoot() {
+    return this.stateTrie.rootHash;
+  }
+}
+
+module.exports = State;

package/store/trie.js

@@ -0,0 +1,60 @@
+const _ = require('lodash');
+const { keccakHash } = require('../util');
+
+class Node {
+  constructor() {
+    this.value = null;
+    this.childMap = {};
+  }
+}
+
+class Trie {
+  constructor() {
+    this.head = new Node();
+    this.generateRootHash();
+  }
+
+  generateRootHash() {
+    this.rootHash = keccakHash(this.head);
+  }
+
+  get({ key }) {
+    let node = this.head;
+
+    for (let character of key) {
+      if (node.childMap[character]) {
+        node = node.childMap[character];
+      }
+    }
+
+    return _.cloneDeep(node.value);
+  }
+
+  put({ key, value }) {
+    let node = this.head;
+
+    for (let character of key) {
+      if (!node.childMap[character]) {
+        node.childMap[character] = new Node();
+      }
+
+      node = node.childMap[character];
+    }
+
+    node.value = value;
+
+    this.generateRootHash();
+  }
+
+  static buildTrie({ items }) {
+    const trie = new this();
+
+    for (let item of items.sort((a, b) => keccakHash(a) > keccakHash(b))) {
+      trie.put({ key: keccakHash(item), value: item });
+    }
+
+    return trie;
+  }
+}
+
+module.exports = Trie;

package/store/trie.test.js

@@ -0,0 +1,56 @@
+const Trie = require('./trie');
+const { keccakHash } = require('../util');
+
+describe('Trie', () => {
+  let trie;
+
+  beforeEach(() => {
+    trie = new Trie();
+  });
+
+  it('has a rootHash', () => {
+    expect(trie.rootHash).not.toBe(undefined);
+  });
+
+  describe('put()', () => {
+    it('stores a value under a key', () => {
+      const key = 'foo';
+      const value = 'bar';
+      trie.put({ key, value });
+
+      expect(trie.get({ key })).toEqual(value);
+    });
+
+    it('generates a new root hash after entering the value', () => {
+      const originalRootHash = trie.rootHash;
+
+      trie.put({ key: 'foo', value: 'bar' });
+
+      expect(trie.rootHash).not.toEqual(originalRootHash);
+    });
+  });
+
+  describe('get()', () => {
+    it('returns a copy of the stored value', () => {
+      const key = 'foo';
+      const value = { one: 1 };
+      trie.put({ key, value });
+      const gottenValue = trie.get({ key });
+      value.one = 2;
+
+      expect(gottenValue).toEqual({ one: 1 });
+    });
+  });
+
+  describe('buildTrie()', () => {
+    it('builds a trie where the items are accessible with their hashes', () => {
+      const item1 = { foo: 'bar' };
+      const item2 = { foo2: 'bar2' };
+
+      trie = Trie.buildTrie({ items: [item1, item2] });
+
+      expect(trie.get({ key: keccakHash(item1) })).toEqual(item1);
+      expect(trie.get({ key: keccakHash(item2) })).toEqual(item2);
+    });
+  });
+});

package/tmp.js

@@ -0,0 +1,16 @@
+const Trie = require('./store/trie');
+const { keccakHash } = require('./util');
+
+const trie = new Trie();
+const accountData = { balance: 1000 };
+const transaction = { data: accountData };
+
+trie.put({ key: 'foo', value: transaction });
+const retrievedTransaction = trie.get({ key: 'foo' });
+const hash1 = keccakHash(retrievedTransaction);
+console.log('hash1', hash1);
+
+accountData.balance += 50;
+
+const hash2 = keccakHash(retrievedTransaction);
+console.log('hash2', hash2);