marsxchain 1.0.0

package/transaction/index.js

@@ -0,0 +1,244 @@
+const uuid = require('uuid/v4');
+const Account = require('../account');
+const Interpreter = require('../interpreter');
+const { MINING_REWARD } = require('../config');
+
+const TRANSACTION_TYPE_MAP = {
+  CREATE_ACCOUNT: 'CREATE_ACCOUNT',
+  TRANSACT: 'TRANSACT',
+  MINING_REWARD: 'MINING_REWARD'
+};
+
+class Transaction {
+  constructor({ id, from, to, value, data, signature, gasLimit }) {
+    this.id = id || uuid();
+    this.from = from || '-';
+    this.to = to || '-';
+    this.value = value || 0;
+    this.data = data || '-';
+    this.signature = signature || '-';
+    this.gasLimit = gasLimit || 0;
+  }
+
+  static createTransaction({ account, to, value, beneficiary, gasLimit }) {
+    if (beneficiary) {
+      return new Transaction({
+        to: beneficiary,
+        value: MINING_REWARD,
+        gasLimit,
+        data: { type: TRANSACTION_TYPE_MAP.MINING_REWARD }
+      });
+    }
+
+    if (to) {
+      const transactionData = {
+        id: uuid(),
+        from: account.address,
+        to,
+        value: value || 0,
+        gasLimit: gasLimit || 0,
+        data: { type: TRANSACTION_TYPE_MAP.TRANSACT }
+      };
+
+      return new Transaction({
+        ...transactionData,
+        signature: account.sign(transactionData)
+      });
+    }
+
+    return new Transaction({
+      data: {
+        type: TRANSACTION_TYPE_MAP.CREATE_ACCOUNT,
+        accountData: account.toJSON()
+      }
+    });
+  }
+
+  static validateStandardTransaction({ state, transaction }) {
+    return new Promise((resolve, reject) => {
+      const { id, from, signature, value, to, gasLimit } = transaction;
+      const transactionData = { ...transaction };
+      delete transactionData.signature;
+
+      if (!Account.verifySignature({
+        publicKey: from,
+        data: transactionData,
+        signature
+      })) {
+        return reject(new Error(`Transaction ${id} signature is invalid`));
+      }
+
+      const fromBalance = state.getAccount({ address: from }).balance;
+
+      if ((value + gasLimit) > fromBalance) {
+        return reject(new Error(
+          `Transaction value and gasLimit: ${value} exceeds balance: ${fromBalance}`
+        ));
+      }
+
+      const toAccount = state.getAccount({ address: to });
+
+      if (!toAccount) {
+        return reject(new Error(
+          `The to field: ${to} does not exist`
+        ));
+      }
+
+      if (toAccount.codeHash) {
+        const { gasUsed } = new Interpreter({
+          storageTrie: state.storageTrieMap[toAccount.codeHash]
+        }).runCode(toAccount.code);
+
+        if (gasUsed > gasLimit) {
+          return reject(new Error(
+            `Transaction needs more gas. Provided: ${gasLimit}. Needs: ${gasUsed}.`
+          ));
+        }
+      }
+
+      return resolve();
+    });
+  }
+
+  static validateCreateAccountTransaction({ transaction }) {
+    return new Promise((resolve, reject) => {
+      const expectedAccountDataFields = Object.keys(new Account().toJSON());
+      const fields = Object.keys(transaction.data.accountData);
+
+      if (fields.length !== expectedAccountDataFields.length) {
+        return reject(
+          new Error(`The transaction account data has an incorrect number of fields`)
+        );
+      }
+
+      fields.forEach(field => {
+        if (!expectedAccountDataFields.includes(field)) {
+          return reject(new Error(
+            `The field: ${field}, is unexpected for account data`
+          ));
+        }
+      });
+
+      return resolve();
+    });
+  }
+
+  static validateMiningRewardTransaction({ transaction }) {
+    return new Promise((resolve, reject) => {
+      const { value } = transaction;
+
+      if (value !== MINING_REWARD) {
+        return reject(new Error(
+          `The provided mining reward value: ${value} does not equal ` +
+          `the official value: ${MINING_REWARD}`
+        ));
+      }
+
+      return resolve();
+    });
+  }
+
+  static validateTransactionSeries({ transactionSeries, state }) {
+    return new Promise(async (resolve, reject) => {
+      for (let transaction of transactionSeries) {
+        try {
+          switch (transaction.data.type) {
+            case TRANSACTION_TYPE_MAP.CREATE_ACCOUNT:
+              await Transaction.validateCreateAccountTransaction({
+                transaction
+              });
+              break;
+            case TRANSACTION_TYPE_MAP.TRANSACT:
+              await Transaction.validateStandardTransaction({
+                state,
+                transaction
+              });
+              break;
+            case TRANSACTION_TYPE_MAP.MINING_REWARD:
+              await Transaction.validateMiningRewardTransaction({
+                state,
+                transaction
+              });
+              break;
+            default:
+              break;
+          } 
+        } catch (error) {
+          return reject(error);
+        }
+      }
+
+      return resolve();
+    });
+  }
+
+  static runTransaction({ state, transaction }) {
+    switch(transaction.data.type) {
+      case TRANSACTION_TYPE_MAP.TRANSACT:
+        Transaction.runStandardTransaction({ state, transaction });
+        console.log(
+          ' -- Updated account data to reflect the standard transaction'
+        );
+        break;
+      case TRANSACTION_TYPE_MAP.CREATE_ACCOUNT:
+        Transaction.runCreateAccountTransaction({ state, transaction });
+        console.log(' -- Stored the account data');
+        break;
+      case TRANSACTION_TYPE_MAP.MINING_REWARD:
+        Transaction.runMiningRewardTransaction({ state, transaction });
+        console.log(' -- Updated account data to reflect the mining reward');
+        break;
+      default:
+        break;
+    }
+  }
+
+  static runStandardTransaction({ state, transaction }) {
+    const fromAccount = state.getAccount({ address: transaction.from });
+    const toAccount = state.getAccount({ address: transaction.to });
+
+    let gasUsed = 0;
+    let result;
+
+    if (toAccount.codeHash) {
+      const interpreter = new Interpreter({
+        storageTrie: state.storageTrieMap[toAccount.codeHash]
+      });
+      ({ gasUsed, result } = interpreter.runCode(toAccount.code));
+
+      console.log(
+        ` -*- Smart contract execution: ${transaction.id} - RESULT: ${result}`
+      );
+    }
+
+    const { value, gasLimit } = transaction;
+    const refund = gasLimit - gasUsed;
+
+    fromAccount.balance -= value;
+    fromAccount.balance -= gasLimit;
+    fromAccount.balance += refund;
+    toAccount.balance += value;
+    toAccount.balance += gasUsed;
+
+    state.putAccount({ address: transaction.from, accountData: fromAccount });
+    state.putAccount({ address: transaction.to, accountData: toAccount });
+  }
+
+  static runCreateAccountTransaction({ state, transaction }) {
+    const { accountData } = transaction.data;
+    const { address, codeHash } = accountData;
+
+    state.putAccount({ address: codeHash ? codeHash : address, accountData });
+  }
+
+  static runMiningRewardTransaction({ state, transaction }) {
+    const { to, value } = transaction;
+    const accountData = state.getAccount({ address: to });
+
+    accountData.balance += value;
+
+    state.putAccount({ address: to, accountData });
+  }
+}
+
+module.exports = Transaction;

package/transaction/index.test.js

@@ -0,0 +1,140 @@
+const Transaction = require('./index');
+const Account = require('../account');
+const State = require('../store/state');
+
+describe('Transaction', () => {
+  let account;
+  let standardTransaction;
+  let createAccountTransaction;
+  let state;
+  let toAccount;
+  let miningRewardTransaction;
+
+  beforeEach(() => {
+    account = new Account();
+    toAccount = new Account();
+    state = new State();
+    state.putAccount({ address: account.address, accountData: account });
+    state.putAccount({ address: toAccount.address, accountData: toAccount });
+
+    standardTransaction = Transaction.createTransaction({
+      account,
+      to: toAccount.address,
+      value: 50
+    });
+    createAccountTransaction = Transaction.createTransaction({
+      account
+    });
+    miningRewardTransaction = Transaction.createTransaction({
+      beneficiary: account.address
+    })
+  });
+
+  describe('validateStandardTransaction()', () => {
+    it('validates a valid transaction', () => {
+      expect(Transaction.validateStandardTransaction({
+        transaction: standardTransaction,
+        state
+      })).resolves;
+    });
+
+    it('does not validate a malformed transaction', () => {
+      standardTransaction.to = 'different-recipient';
+
+      expect(Transaction.validateStandardTransaction({
+        transaction: standardTransaction,
+        state
+      })).rejects.toMatchObject({ message: /invalid/ });
+    });
+
+    it('does not validate when the value exceeds the balance', () => {
+      standardTransaction = Transaction.createTransaction({
+        account,
+        to: toAccount.address,
+        value: 9001
+      });
+
+      expect(Transaction.validateStandardTransaction({
+        transaction: standardTransaction,
+        state
+      })).rejects.toMatchObject({ message: /exceeds/ });      
+    });
+
+    it('does not validate when the `to` address does not exist', () => {
+      standardTransaction = Transaction.createTransaction({
+        account,
+        to: 'foo-recipient',
+        value: 50
+      });
+
+      expect(Transaction.validateStandardTransaction({
+        transaction: standardTransaction,
+        state
+      })).rejects.toMatchObject({ message: /does not exist/ });
+    });
+
+    it('does not validate when the gasLimit exceeds the balance', () => {
+      standardTransaction = Transaction.createTransaction({
+        account,
+        to: 'foo-recipient',
+        gasLimit: 9001
+      });
+
+      expect(Transaction.validateStandardTransaction({
+        transaction: standardTransaction,
+        state
+      })).rejects.toMatchObject({ message: /exceeds/ });
+    });
+
+    it('does not validate when the gasUsed for the code exceeds the gasLimit', () => {
+      const codeHash = 'foo-codeHash';
+      const code = ['PUSH', 1, 'PUSH', 2, 'ADD', 'STOP'];
+
+      state.putAccount({
+        address: codeHash,
+        accountData: { code, codeHash }
+      });
+
+      standardTransaction = Transaction.createTransaction({
+        account,
+        to: codeHash,
+        gasLimit: 0
+      });
+
+      expect(Transaction.validateStandardTransaction({
+        transaction: standardTransaction,
+        state
+      })).rejects.toMatchObject({ message: /Transaction needs more gas/ });      
+    });
+  });
+
+  describe('validateCreateAccountTransaction()', () => {
+    it('validates a create account transaction', () => {
+      expect(Transaction.validateCreateAccountTransaction({
+        transaction: createAccountTransaction
+      })).resolves;
+    });
+
+    it('does not validate a non create account transaction', () => {
+      expect(Transaction.validateCreateAccountTransaction({
+        transaction: standardTransaction
+      })).rejects.toMatchObject({ message: /incorrect/ });
+    });
+  });
+
+  describe('validateMiningRewardTransaction', () => {
+    it('validates a mining reward transaction', () => {
+      expect(Transaction.validateMiningRewardTransaction({
+        transaction: miningRewardTransaction
+      })).resolves;
+    });
+
+    it('does not validate a tampered with mining reward transaction', () => {
+      miningRewardTransaction.value = 9001;
+
+      expect(Transaction.validateMiningRewardTransaction({
+        transaction: miningRewardTransaction
+      })).rejects.toMatchObject({ message: /does not equal the official/ });
+    });
+  });
+});

package/transaction/transaction-queue.js

@@ -0,0 +1,21 @@
+class TransactionQueue {
+  constructor() {
+    this.transactionMap = {};
+  }
+
+  add(transaction) {
+    this.transactionMap[transaction.id] = transaction;
+  }
+
+  getTransactionSeries() {
+    return Object.values(this.transactionMap);
+  }
+
+  clearBlockTransactions({ transactionSeries }) {
+    for (let transaction of transactionSeries) {
+      delete this.transactionMap[transaction.id];
+    }
+  }
+}
+
+module.exports = TransactionQueue;

package/util/index.js

@@ -0,0 +1,22 @@
+const keccak256 = require('js-sha3').keccak256;
+const EC = require('elliptic').ec;
+
+const ec = new EC('secp256k1');
+
+const sortCharacters = data => {
+  return JSON.stringify(data).split('').sort().join('');
+}
+
+const keccakHash = data => {
+  const hash = keccak256.create();
+
+  hash.update(sortCharacters(data));
+
+  return hash.hex();
+}
+
+module.exports = {
+  sortCharacters,
+  keccakHash,
+  ec
+};

package/util/index.test.js

@@ -0,0 +1,22 @@
+const { sortCharacters, keccakHash } = require('./index');
+
+describe('util', () => {
+  describe('sortCharacters()', () => {
+    it('creates the same string for objects with the same properties in a different order', () => {
+      expect(sortCharacters({ foo: 'foo', bar: 'bar' }))
+        .toEqual(sortCharacters({ bar: 'bar', foo: 'foo' }));
+    });
+
+    it('creates a different string for different objects', () => {
+      expect(sortCharacters({ foo: 'foo' }))
+        .not.toEqual(sortCharacters({ bar: 'bar' }));
+    });
+  });
+
+  describe('keccakHash()', () => {
+    it('produces a keccak256 hash', () => {
+      expect(keccakHash('foo'))
+        .toEqual('b2a7ad9b4a2ee6d984cc5c2ad81d0c2b2902fa410670aa3f2f4f668a1f80611c');
+    });
+  });
+});