marsxchain 1.0.0

package/README.md

@@ -0,0 +1,28 @@
+## Build Ethereum From Scratch - Smart Contracts and More
+
+![Course Logo](course_logo_udemy.png)
+
+This repository accompanies the "Build Ethereum From Scratch - Smart Contracts and More"
+course by David Katz.
+
+#### Take the course here:
+
+[https://www.udemy.com/build-ethereum-from-scratch?couponCode=GITHUB](https://www.udemy.com/build-ethereum-from-scratch?couponCode=GITHUB)
+
+In the course, you will build your own version of Ethereum. Ethereum can be described in two words. It's a:
+
+#### Decentralized Computer.
+
+A decentralized computer is like a normal computer. A normal computer executes a program using one machine.
+
+But a decentralized computer executes a program using multiple machines. Every machine needs to agree upon the output of the program for its results to become official.
+
+To build a decentralized computer, here are the essential elements:
+
+1) A smart contract language.
+2) A blockchain.
+3) A network.
+4) Transactions and accounts.
+5) A state management data structure.
+
+Definitely take the course if you're interested in exploring the concepts behind this project more deeply. The course is a line-by-line tutorial of this entire repository. And by the end of the course, you'll have your own version of Ethereum.

package/account/index.js

@@ -0,0 +1,43 @@
+const { ec, keccakHash } = require('../util');
+const { STARTING_BALANCE } = require('../config');
+
+class Account {
+  constructor({ code } = {}) {
+    this.keyPair = ec.genKeyPair();
+    this.address = this.keyPair.getPublic().encode('hex');
+    this.balance = STARTING_BALANCE;
+    this.code = code || [];
+    this.generateCodeHash();
+  }
+
+  generateCodeHash() {
+    this.codeHash = this.code.length > 0
+      ? keccakHash(this.address + this.code)
+      : null;
+  }
+
+  sign(data) {
+    return this.keyPair.sign(keccakHash(data));
+  }
+
+  toJSON() {
+    return {
+      address: this.address,
+      balance: this.balance,
+      code: this.code,
+      codeHash: this.codeHash
+    };
+  }
+
+  static verifySignature({ publicKey, data, signature }) {
+    const keyFromPublic = ec.keyFromPublic(publicKey, 'hex');
+
+    return keyFromPublic.verify(keccakHash(data), signature);
+  }
+
+  static calculateBalance({ address, state }) {
+    return state.getAccount({ address }).balance;
+  }
+}
+
+module.exports = Account;

package/account/index.test.js

@@ -0,0 +1,29 @@
+const Account = require('./index');
+
+describe('Account', () => {
+  let account, data, signature;
+
+  beforeEach(() => {
+    account = new Account();
+    data = { foo: 'foo' };
+    signature = account.sign(data);
+  });
+
+  describe('verifySignature()', () => {
+    it('validates a signature generated by the account', () => {
+      expect(Account.verifySignature({
+        publicKey: account.address,
+        data,
+        signature
+      })).toBe(true);
+    });
+
+    it('invalidates a signature not generated by the account', () => {
+      expect(Account.verifySignature({
+        publicKey: new Account().address,
+        data,
+        signature
+      })).toBe(false);
+    });
+  });
+});

package/api/index.js

@@ -0,0 +1,96 @@
+const express = require('express');
+const bodyParser = require('body-parser');
+const request = require('request');
+const Account = require('../account');
+const Blockchain = require('../blockchain');
+const Block = require('../blockchain/block');
+const PubSub = require('./pubsub');
+const State = require('../store/state');
+const Transaction = require('../transaction');
+const TransactionQueue = require('../transaction/transaction-queue');
+
+const app = express();
+app.use(bodyParser.json());
+
+const state = new State();
+const blockchain = new Blockchain({ state });
+const transactionQueue = new TransactionQueue();
+const pubsub = new PubSub({ blockchain, transactionQueue });
+const account = new Account();
+const transaction = Transaction.createTransaction({ account });
+
+setTimeout(() => {
+  pubsub.broadcastTransaction(transaction);
+}, 500);
+
+app.get('/blockchain', (req, res, next) => {
+  const { chain } = blockchain;
+
+  res.json({ chain });
+});
+
+app.get('/blockchain/mine', (req, res, next) => {
+  const lastBlock = blockchain.chain[blockchain.chain.length-1];
+  const block = Block.mineBlock({
+    lastBlock,
+    beneficiary: account.address,
+    transactionSeries: transactionQueue.getTransactionSeries(),
+    stateRoot: state.getStateRoot()
+  });
+
+  blockchain.addBlock({ block, transactionQueue })
+    .then(() => {
+      pubsub.broadcastBlock(block);
+
+      res.json({ block });
+    })
+    .catch(next);
+});
+
+app.post('/account/transact', (req, res, next) => {
+  const { code, gasLimit, to, value } = req.body;
+  const transaction = Transaction.createTransaction({
+    account: !to ? new Account({ code }) : account,
+    gasLimit,
+    to,
+    value
+  });
+
+  pubsub.broadcastTransaction(transaction);
+
+  res.json({ transaction });
+});
+
+app.get('/account/balance', (req, res, next) => {
+  const { address } = req.query;
+
+  const balance = Account.calculateBalance({
+    address: address || account.address,
+    state
+  });
+
+  res.json({ balance });
+});
+
+app.use((err, req, res, next) => {
+  console.error('Internal server error:', err);
+
+  res.status(500).json({ message: err.message });
+});
+
+const peer = process.argv.includes('--peer');
+const PORT = peer
+  ? Math.floor(2000 + Math.random() * 1000)
+  : 3000;
+
+if (peer) {
+  request('http://localhost:3000/blockchain', (error, response, body) => {
+    const { chain } = JSON.parse(body);
+
+    blockchain.replaceChain({ chain })
+      .then(() => console.log('Synchronized blockchain with the root node'))
+      .catch(error => console.error('Synchronization error:', error.message));
+  });
+}
+
+app.listen(PORT, () => console.log(`Listening at PORT: ${PORT}`));

package/api/pubsub.js

@@ -0,0 +1,81 @@
+const PubNub = require('pubnub');
+const Transaction = require('../transaction');
+
+const credentials = {
+  publishKey: 'pub-c-1624883b-89a7-4a67-8438-447deac585a1',
+  subscribeKey: 'sub-c-94cf1061-53fc-447d-a7a6-dc2ce2cbc335',
+  secretKey: 'sec-c-OWUxOTFmNzctMTk1ZS00ZmM5LWJmOGYtZmE0YTIzMDNjNDY0'
+};
+
+const CHANNELS_MAP = {
+  TEST: 'TEST',
+  BLOCK: 'BLOCK',
+  TRANSACTION: 'TRANSACTION'
+};
+
+class PubSub {
+  constructor({ blockchain, transactionQueue }) {
+    this.pubnub = new PubNub(credentials);
+    this.blockchain = blockchain;
+    this.transactionQueue = transactionQueue;
+    this.subscribeToChannels();
+    this.listen();
+  }
+
+  subscribeToChannels() {
+    this.pubnub.subscribe({
+      channels: Object.values(CHANNELS_MAP)
+    });
+  }
+
+  publish({ channel, message }) {
+    this.pubnub.publish({ channel, message });
+  }
+
+  listen() {
+    this.pubnub.addListener({
+      message: messageObject => {
+        const { channel, message } = messageObject;
+        const parsedMessage = JSON.parse(message);
+
+        console.log('Message received. Channel:', channel);
+
+        switch (channel) {
+          case CHANNELS_MAP.BLOCK:
+            console.log('block message', message);
+
+            this.blockchain.addBlock({
+              block: parsedMessage,
+              transactionQueue: this.transactionQueue
+            }).then(() => console.log('New block accepted', parsedMessage))
+              .catch(error => console.error('New block rejected:', error.message));
+            break;
+          case CHANNELS_MAP.TRANSACTION:
+            console.log(`Received transaction: ${parsedMessage.id}`);
+
+            this.transactionQueue.add(new Transaction(parsedMessage));
+
+            break;
+          default:
+            return;
+        }
+      }
+    });
+  }
+
+  broadcastBlock(block) {
+    this.publish({
+      channel: CHANNELS_MAP.BLOCK,
+      message: JSON.stringify(block)
+    });
+  }
+
+  broadcastTransaction(transaction) {
+    this.publish({
+      channel: CHANNELS_MAP.TRANSACTION,
+      message: JSON.stringify(transaction)
+    });
+  }
+}
+
+module.exports = PubSub;

package/api-test.js

@@ -0,0 +1,112 @@
+const request = require('request');
+
+const { OPCODE_MAP } = require('./interpreter');
+const { STOP, ADD, PUSH, STORE, LOAD } = OPCODE_MAP;
+
+const BASE_URL = 'http://localhost:3000';
+
+const postTransact = ({ code, to, value, gasLimit }) => {
+  return new Promise((resolve, reject) => {
+    request(`${BASE_URL}/account/transact`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ code, to, value, gasLimit })
+    },(error, response, body) => {
+      return resolve(JSON.parse(body));
+    });
+  });
+}
+
+const getMine = () => {
+  return new Promise((resolve, reject) => {
+    setTimeout(() => {
+      request(`${BASE_URL}/blockchain/mine`, (error, response, body) => {
+        return resolve(JSON.parse(body));
+      });
+    }, 3000);
+  });
+}
+
+const getAccountBalance = ({ address } = {}) => {
+  return new Promise((resolve, reject) => {
+    request(
+      `${BASE_URL}/account/balance` + (address ? `?address=${address}` : ''),
+      (error, response, body) => {
+        return resolve(JSON.parse(body));
+      }
+    );
+  });
+}
+
+let toAccountData;
+let smartContractAccountData;
+
+postTransact({})
+  .then(postTransactResponse => {
+    console.log(
+      'postTransactResponse (Create Account Transaction)',
+      postTransactResponse
+    );
+
+    toAccountData = postTransactResponse.transaction.data.accountData;
+
+    return getMine();
+  }).then(getMineResponse => {
+    console.log('getMineResponse', getMineResponse);
+
+    return postTransact({ to: toAccountData.address, value: 20 });
+  })
+  .then(postTransactResponse2 => {
+    console.log(
+      'postTransactResponse2 (Standard Transaction)',
+      postTransactResponse2
+    );
+
+    const key = 'foo';
+    const value = 'bar';
+    const code = [PUSH, value, PUSH, key, STORE, PUSH, key, LOAD, STOP];
+
+    return postTransact({ code });
+  })
+  .then(postTransactResponse3 => {
+    console.log(
+      'postTransactResponse3 (Smart Contract)',
+      postTransactResponse3
+    );
+
+    smartContractAccountData = postTransactResponse3
+      .transaction
+      .data
+      .accountData;
+
+    return getMine();
+  })
+  .then(getMineResponse2 => {
+    console.log('getMineResponse2', getMineResponse2);
+
+    return postTransact({
+      to: smartContractAccountData.codeHash,
+      value: 0,
+      gasLimit: 100
+    });
+  })
+  .then(postTransactResponse4 => {
+    console.log(
+      'postTransactResponse4 (to the smart contract)',
+      postTransactResponse4
+    );
+    return getMine();
+  })
+  .then(getMineResponse3 => {
+    console.log('getMineResponse3', getMineResponse3);
+
+    return getAccountBalance();
+  })
+  .then(getAccountBalanceResponse => {
+    console.log('getAccountBalanceResponse', getAccountBalanceResponse);
+
+    return getAccountBalance({ address: toAccountData.address });
+  })
+  .then(getAccountBalanceResponse2 => {
+    console.log('getAccountBalanceResponse2', getAccountBalanceResponse2);
+  });

package/blockchain/block.js

@@ -0,0 +1,144 @@
+const { GENESIS_DATA, MINE_RATE } = require('../config');
+const { keccakHash } = require('../util');
+const Transaction = require('../transaction');
+const Trie = require('../store/trie');
+
+const HASH_LENGTH = 64;
+const MAX_HASH_VALUE = parseInt('f'.repeat(HASH_LENGTH), 16);
+const MAX_NONCE_VALUE = 2 ** 64;
+
+class Block {
+  constructor({ blockHeaders, transactionSeries }) {
+    this.blockHeaders = blockHeaders;
+    this.transactionSeries = transactionSeries;
+  }
+
+  static calculateBlockTargetHash({ lastBlock }) {
+    const value = (MAX_HASH_VALUE / lastBlock.blockHeaders.difficulty).toString(16);
+
+    if (value.length > HASH_LENGTH) {
+      return 'f'.repeat(HASH_LENGTH);
+    }
+
+    return '0'.repeat(HASH_LENGTH - value.length) + value;
+  }
+
+  static adjustDifficulty({ lastBlock, timestamp }) {
+    const { difficulty } = lastBlock.blockHeaders;
+
+    if ((timestamp - lastBlock.blockHeaders.timestamp) > MINE_RATE) {
+      return difficulty - 1;
+    }
+
+    if (difficulty < 1) {
+      return 1;
+    }
+
+    return difficulty + 1;
+  }
+
+  static mineBlock({
+    lastBlock,
+    beneficiary,
+    transactionSeries,
+    stateRoot
+  }) {
+    const target = Block.calculateBlockTargetHash({ lastBlock });
+    const miningRewardTransaction = Transaction.createTransaction({
+      beneficiary
+    });
+    transactionSeries.push(miningRewardTransaction);
+    const transactionsTrie = Trie.buildTrie({ items: transactionSeries });
+    let timestamp, truncatedBlockHeaders, header, nonce, underTargetHash;
+
+    do {
+      timestamp = Date.now();
+      truncatedBlockHeaders = {
+        parentHash: keccakHash(lastBlock.blockHeaders),
+        beneficiary,
+        difficulty: Block.adjustDifficulty({ lastBlock, timestamp }),
+        number: lastBlock.blockHeaders.number + 1,
+        timestamp,
+        transactionsRoot: transactionsTrie.rootHash,
+        stateRoot
+      };
+      header = keccakHash(truncatedBlockHeaders);
+      nonce = Math.floor(Math.random() * MAX_NONCE_VALUE);
+  
+      underTargetHash = keccakHash(header + nonce);
+    } while (underTargetHash > target);
+
+    return new this({
+      blockHeaders: { ...truncatedBlockHeaders, nonce },
+      transactionSeries
+    });
+  }
+
+  static genesis() {
+    return new Block(GENESIS_DATA);
+  }
+
+  static validateBlock({ lastBlock, block, state }) {
+    return new Promise((resolve, reject) => {
+      if (keccakHash(block) === keccakHash(Block.genesis())) {
+        return resolve();
+      }
+
+      if (keccakHash(lastBlock.blockHeaders) !== block.blockHeaders.parentHash) {
+        return reject(
+          new Error("The parent hash must be a hash of the last block's headers")
+        );
+      }
+
+      if (block.blockHeaders.number !== lastBlock.blockHeaders.number + 1) {
+        return reject(new Error('The block must increment the number by 1'));
+      }
+
+      if (
+        Math.abs(lastBlock.blockHeaders.difficulty - block.blockHeaders.difficulty) > 1
+      ) {
+        return reject(new Error('The difficulty must only adjust by 1'));
+      }
+
+      const rebuiltTransactionsTrie = Trie.buildTrie({
+        items: block.transactionSeries
+      });
+
+      if (rebuiltTransactionsTrie.rootHash !== block.blockHeaders.transactionsRoot) {
+        return reject(
+          new Error(
+            `The rebuilt transactions root does not match the block's ` +
+            `transactions root: ${block.blockHeaders.transactionRoot}`
+          )
+        );
+      }
+
+      const target = Block.calculateBlockTargetHash({ lastBlock });
+      const { blockHeaders } = block;
+      const { nonce } = blockHeaders;
+      const truncatedBlockHeaders = { ...blockHeaders };
+      delete truncatedBlockHeaders.nonce;
+      const header = keccakHash(truncatedBlockHeaders);
+      const underTargetHash = keccakHash(header + nonce);
+
+      if (underTargetHash > target) {
+        return reject(new Error(
+          'The block does not meet the proof of work requirement'
+        ));
+      }
+
+      Transaction.validateTransactionSeries({
+        state, transactionSeries: block.transactionSeries
+      }).then(resolve)
+        .catch(reject);
+    });
+  }
+
+  static runBlock({ block, state }) {
+    for (let transaction of block.transactionSeries) {
+      Transaction.runTransaction({ transaction, state });
+    }
+  }
+}
+
+module.exports = Block;

package/blockchain/block.test.js

@@ -0,0 +1,160 @@
+const Block = require('./block');
+const State = require('../store/state');
+const { keccakHash } = require('../util');
+
+describe('Block', () => {
+  describe('calculateBlockTargetHash()', () => {
+    it('calculates the maximum hash when the last block difficulty is 1', () => {
+      expect(
+        Block
+          .calculateBlockTargetHash({ lastBlock: { blockHeaders: { difficulty: 1 } } })
+      ).toEqual('f'.repeat(64));
+    });
+
+    it('calculates a low hash value when the last block difficulty is high', () => {
+      expect(
+        Block
+          .calculateBlockTargetHash({ lastBlock: { blockHeaders: { difficulty: 500 } } })
+        < '1'
+      ).toBe(true);
+    });
+  });
+
+  describe('mineBlock()', () => {
+    let lastBlock, minedBlock;
+
+    beforeEach(() => {
+      lastBlock = Block.genesis();
+      minedBlock = Block.mineBlock({
+        lastBlock,
+        beneficiary: 'beneficiary',
+        transactionSeries: []
+      });
+    });
+
+    it('mines a block', () => {
+      expect(minedBlock).toBeInstanceOf(Block);
+    });
+
+    it('mines a block that meets the proof of work requirement', () => {
+      const target = Block.calculateBlockTargetHash({ lastBlock });
+      const { blockHeaders } = minedBlock;
+      const { nonce } = blockHeaders;
+      const truncatedBlockHeaders = { ...blockHeaders };
+      delete truncatedBlockHeaders.nonce;
+      const header = keccakHash(truncatedBlockHeaders);
+      const underTargetHash = keccakHash(header + nonce);
+
+      expect(underTargetHash < target).toBe(true);
+    });
+  });
+
+  describe('adjustDifficulty()', () => {
+    it('keeps the difficulty above 0', () => {
+      expect(
+        Block.adjustDifficulty({
+          lastBlock: { blockHeaders: { difficulty: 0 } },
+          timestamp: Date.now()
+        })
+      ).toEqual(1);
+    });
+
+    it('increases the difficulty for a quickly mined block', () => {
+      expect(
+        Block.adjustDifficulty({
+          lastBlock: { blockHeaders: { difficulty: 5, timestamp: 1000 } },
+          timestamp: 3000
+        })
+      ).toEqual(6);
+    });
+
+    it('decreases the difficulty for a slowly mined block', () => {
+      expect(
+        Block.adjustDifficulty({
+          lastBlock: { blockHeaders: { difficulty: 5, timestamp: 1000 } },
+          timestamp: 20000
+        })
+      ).toEqual(4);
+    });
+  });
+
+  describe('validateBlock()', () => {
+    let block, lastBlock, state;
+
+    beforeEach(() => {
+      lastBlock = Block.genesis();
+      block = Block.mineBlock({
+        lastBlock,
+        beneficiary: 'beneficiary',
+        transactionSeries: []
+      });
+      state = new State();
+    });
+
+    it('resolves when the block is the genesis block', () => {
+      expect(Block.validateBlock({
+        block: Block.genesis(),
+        state
+      })).resolves;
+    });
+
+    it('resolves if block is valid', () => {
+      expect(Block.validateBlock({ lastBlock, block, state })).resolves;
+    });
+
+    it('rejects when the parentHash is invalid', () => {
+      block.blockHeaders.parentHash = 'foo';
+
+      expect(Block.validateBlock({ lastBlock, block, state }))
+        .rejects
+        .toMatchObject({
+          message: "The parent hash must be a hash of the last block's headers"
+        });
+    });
+
+    it('rejects when the number is not increased by one', () => {
+      block.blockHeaders.number = 500;
+
+      expect(Block.validateBlock({ lastBlock, block, state }))
+        .rejects
+        .toMatchObject({
+          message: 'The block must increment the number by 1'
+        });
+    });
+
+    it('rejects when the difficulty adjusts by more than 1', () => {
+      block.blockHeaders.difficulty = 999;
+
+      expect(Block.validateBlock({ lastBlock, block, state }))
+        .rejects
+        .toMatchObject({
+          message: 'The difficulty must only adjust by 1'
+        });
+    });
+
+    it('rejects when the proof of work requirement is not met', () => {
+      const originalCalculateBlockTargetHash = Block.calculateBlockTargetHash;
+      Block.calculateBlockTargetHash = () => {
+        return '0'.repeat(64);
+      }
+
+      expect(Block.validateBlock({ lastBlock, block, state }))
+        .rejects
+        .toMatchObject({
+          message: 'The block does not meet the proof of work requirement'
+        });
+
+      Block.calculateBlockTargetHash = originalCalculateBlockTargetHash;
+    });
+
+    it('rejects when the transactionSeries is not valid', () => {
+      block.transactionSeries = ['foo'];
+
+      expect(Block.validateBlock({ state, lastBlock, block }))
+        .rejects
+        .toMatchObject({
+          message: /rebuilt transactions root does not match/
+        });
+    });
+  });
+});