Set up validTransactionData tests

15Dkatz · Nov 15, 2018 · e915ea1 · e915ea1
1 parent 04db7d5
commit e915ea1
Show file tree

Hide file tree

Showing 4 changed files with 162 additions and 4 deletions.
diff --git a/blockchain/index.test.js b/blockchain/index.test.js
@@ -1,6 +1,8 @@
 const Blockchain = require('./index');
 const Block = require('./block');
 const { cryptoHash } = require('../util');
+const Wallet = require('../wallet');
+const Transaction = require('../wallet/transaction');
 
 describe('Blockchain', () => {
   let blockchain, newChain, originalChain;
@@ -151,4 +153,54 @@ describe('Blockchain', () => {
       });
     });
   });
+
+  describe('validTransactionData()', () => {
+    let transaction, rewardTransaction, wallet;
+
+    beforeEach(() => {
+      wallet = new Wallet();
+      transaction = wallet.createTransaction({ recipient: 'foo-address', amount: 65 });
+      rewardTransaction = Transaction.rewardTransaction({ minerWallet: wallet });
+    });
+
+    describe('and the transaction data is valid', () => {
+      it('returns true', () => {
+        newChain.addBlock({ data: [transaction, rewardTransaction] });
+
+        expect(blockchain.validTransactionData({ chain: newChain.chain })).toBe(true);
+      });
+    });
+
+    describe('and the transaction data has multiple rewards', () => {
+      it('returns false', () => {
+        newChain.addBlock({ data: [transaction, rewardTransaction, rewardTransaction] });
+
+        expect(blockchain.validTransactionData({ chain: newChain.chain })).toBe(false);
+      });
+    });
+
+    describe('and the transaction data has at least one malformed outputMap', () => {
+      describe('and the transaction is not a reward transaction', () => {
+        it('returns false', () => {
+          transaction.outputMap[wallet.publicKey] = 999999;
+
+          newChain.addBlock({ data: [transaction, rewardTransaction] });
+
+          expect(blockchain.validTransactionData({ chain: newChain.chain })).toBe(false);
+        });
+      });
+
+      describe('and the transaction is a reward transaction', () => {
+        it('returns false', () => {});
+      });
+    });
+
+    describe('and the transaction data has at least one malformed input', () => {
+      it('returns false', () => {});
+    });
+
+    describe('and a block contains multiple identical transactions', () => {
+      it('returns false', () => {});
+    });
+  });
 });
diff --git a/index.js b/index.js
@@ -43,7 +43,11 @@ app.post('/api/transact', (req, res) => {
     if (transaction) {
       transaction.update({ senderWallet: wallet, recipient, amount });
     } else {
-      transaction = wallet.createTransaction({ recipient, amount });
+      transaction = wallet.createTransaction({
+        recipient,
+        amount,
+        chain: blockchain.chain
+      });
     }
   } catch(error) {
     return res.status(400).json({ type: 'error', message: error.message });
@@ -66,6 +70,15 @@ app.get('/api/mine-transactions', (req, res) => {
   res.redirect('/api/blocks');
 });
 
+app.get('/api/wallet-info', (req, res) => {
+  const address = wallet.publicKey;
+
+  res.json({
+    address,
+    balance: Wallet.calculateBalance({ chain: blockchain.chain, address })
+  });
+});
+
 const syncWithRootState = () => {
   request({ url: `${ROOT_NODE_ADDRESS}/api/blocks` }, (error, response, body) => {
     if (!error && response.statusCode === 200) {

diff --git a/wallet/index.js b/wallet/index.js
@@ -15,7 +15,14 @@ class Wallet {
     return this.keyPair.sign(cryptoHash(data))
   }
 
-  createTransaction({ recipient, amount }) {
+  createTransaction({ recipient, amount, chain }) {
+    if (chain) {
+      this.balance = Wallet.calculateBalance({
+        chain,
+        address: this.publicKey
+      });
+    }
+
     if (amount > this.balance) {
       throw new Error('Amount exceeds balance');
     }
@@ -24,21 +31,30 @@ class Wallet {
   }
 
   static calculateBalance({ chain, address }) {
+    let hasConductedTransaction = false;
     let outputsTotal = 0;
 
-    for (let i=1; i<chain.length; i++) {
+    for (let i=chain.length-1; i>0; i--) {
       const block = chain[i];
 
       for (let transaction of block.data) {
+        if (transaction.input.address === address) {
+          hasConductedTransaction = true;
+        }
+
         const addressOutput = transaction.outputMap[address];
 
         if (addressOutput) {
           outputsTotal = outputsTotal + addressOutput;
         }
       }
+
+      if (hasConductedTransaction) {
+        break;
+      }
     }
 
-    return STARTING_BALANCE + outputsTotal;
+    return hasConductedTransaction ? outputsTotal : STARTING_BALANCE + outputsTotal;
   }
 };
 

diff --git a/wallet/index.test.js b/wallet/index.test.js
@@ -72,6 +72,26 @@ describe('Wallet', () => {
         expect(transaction.outputMap[recipient]).toEqual(amount);
       });
     });
+
+    describe('and a chain is passed', () => {
+      it('calls `Wallet.calculateBalance`', () => {
+        const calculateBalanceMock = jest.fn();
+
+        const originalCalculateBalance = Wallet.calculateBalance;
+
+        Wallet.calculateBalance = calculateBalanceMock;
+
+        wallet.createTransaction({
+          recipient: 'foo',
+          amount: 10,
+          chain: new Blockchain().chain
+        });
+
+        expect(calculateBalanceMock).toHaveBeenCalled();
+
+        Wallet.calculateBalance = originalCalculateBalance;
+      });
+    });
   });
 
   describe('calculateBalance()', () => {
@@ -121,6 +141,63 @@ describe('Wallet', () => {
           transactionTwo.outputMap[wallet.publicKey]
         );
       });
+
+      describe('and the wallet has made a transaction', () => {
+        let recentTransaction;
+
+
+        beforeEach(() => {
+          recentTransaction = wallet.createTransaction({
+            recipient: 'foo-address',
+            amount: 30
+          });
+
+          blockchain.addBlock({ data: [recentTransaction] });
+        });
+
+        it('returns the output amount of the recent transaction', () => {
+          expect(
+            Wallet.calculateBalance({
+              chain: blockchain.chain,
+              address: wallet.publicKey
+            })
+          ).toEqual(recentTransaction.outputMap[wallet.publicKey]);
+        });
+
+        describe('and there are outputs next to and after the recent transaction', () => {
+          let sameBlockTransaction, nextBlockTransaction;
+
+          beforeEach(() => {
+            recentTransaction = wallet.createTransaction({
+              recipient: 'later-foo-address',
+              amount: 60
+            });
+
+            sameBlockTransaction = Transaction.rewardTransaction({ minerWallet: wallet });
+
+            blockchain.addBlock({ data: [recentTransaction, sameBlockTransaction] });
+
+            nextBlockTransaction = new Wallet().createTransaction({
+              recipient: wallet.publicKey, amount: 75
+            });
+
+            blockchain.addBlock({ data: [nextBlockTransaction] });
+          });
+
+          it('includes the output amounts in the returned balance', () => {
+            expect(
+              Wallet.calculateBalance({
+                chain: blockchain.chain,
+                address: wallet.publicKey
+              })
+            ).toEqual(
+              recentTransaction.outputMap[wallet.publicKey] +
+              sameBlockTransaction.outputMap[wallet.publicKey] +
+              nextBlockTransaction.outputMap[wallet.publicKey]
+            );
+          });
+        });
+      });
     });
   });
 });