From 67a5ef552ceb57b5abd93aef297cfb7cb5a86a9c Mon Sep 17 00:00:00 2001
From: loehnertz <jakob2102@gmail.com>
Date: Thu, 8 Feb 2018 22:05:08 +0100
Subject: [PATCH] Put a 'return' statement in front of every 'resolve()' and
 'reject()' inside of Promises to avoid bugs

---
 app/ccurl-interface.js | 10 +++++-----
 app/tanglestash.js     | 38 +++++++++++++++++++-------------------
 2 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/app/ccurl-interface.js b/app/ccurl-interface.js
index 725d79a..46de7b4 100644
--- a/app/ccurl-interface.js
+++ b/app/ccurl-interface.js
@@ -39,10 +39,10 @@ class CcurlInterface {
                 this.checkInput();
                 this.loopTrytes(this.index);
             } catch (err) {
-                reject(err);
+                return reject(err);
             }
             setInterval(() => {
-                if (this.finishedPoW) resolve(this.finalBundleTrytes.reverse());
+                if (this.finishedPoW) return resolve(this.finalBundleTrytes.reverse());
             }, 1234);
         });
     };
@@ -103,11 +103,11 @@ class CcurlInterface {
 
             let newTrytes = this.iota.utils.transactionTrytes(txObject);
             this.libccurl.ccurl_pow.async(newTrytes, this.minWeightMagnitude, (err, returnedTrytes) => {
-                if (err) reject(err);
+                if (err) return reject(err);
 
                 // Check that the PoW actually succeeded
                 if (!returnedTrytes) {
-                    reject(new TanglestashCustomErrors.LibccurlInterruptionError('PoW failed!'));
+                    return reject(new TanglestashCustomErrors.LibccurlInterruptionError('PoW failed!'));
                 } else {
                     let newTxObject = this.iota.utils.transactionObject(returnedTrytes);
 
@@ -116,7 +116,7 @@ class CcurlInterface {
                     // Push the returned trytes to the bundle array
                     this.finalBundleTrytes.push(returnedTrytes);
 
-                    resolve();
+                    return resolve();
                 }
             });
         });
diff --git a/app/tanglestash.js b/app/tanglestash.js
index 4aa0817..5029e34 100644
--- a/app/tanglestash.js
+++ b/app/tanglestash.js
@@ -158,9 +158,9 @@ class Tanglestash {
                 if (this.successfulChunks === this.totalChunkAmount) {
                     clearInterval(finishedCheck);
                     try {
-                        resolve(this.chunkBundle);
+                        return resolve(this.chunkBundle);
                     } catch (err) {
-                        reject(err);
+                        return reject(err);
                     }
                 } else {
                     for (let chunk in this.failedChunks) {
@@ -225,20 +225,20 @@ class Tanglestash {
                 if (err) {
                     switch (err.message) {
                         case 'Invalid inputs provided.':
-                            reject(new TanglestashCustomErrors.IncorrectTransactionHashError(err.message));
+                            return reject(new TanglestashCustomErrors.IncorrectTransactionHashError(err.message));
                             break;
                         case 'Invalid Bundle provided.':
-                            reject(new TanglestashCustomErrors.NodeOutdatedError(err.message));
+                            return reject(new TanglestashCustomErrors.NodeOutdatedError(err.message));
                             break;
                         case 'Invalid tail transaction supplied.':
-                            reject(new TanglestashCustomErrors.MalformedPersistedDataError(err.message));
+                            return reject(new TanglestashCustomErrors.MalformedPersistedDataError(err.message));
                             break;
                         default:
-                            reject(new Error(err.message));
+                            return reject(new Error(err.message));
                             break;
                     }
                 }
-                resolve(transactionBundle);
+                return resolve(transactionBundle);
             });
         });
     }
@@ -387,12 +387,12 @@ class Tanglestash {
     getParentTransactions() {
         return new Promise((resolve, reject) => {
             this.iota.api.getTransactionsToApprove(this.IotaTransactionDepth, null, (err, transactions) => {
-                if (err) reject(err);
+                if (err) return reject(err);
 
                 if (!transactions) {
-                    reject(new TanglestashCustomErrors.NodeCouldNotProvideTransactionsToApproveError());
+                    return reject(new TanglestashCustomErrors.NodeCouldNotProvideTransactionsToApproveError());
                 } else {
-                    resolve({
+                    return resolve({
                         trunkTransaction: transactions.trunkTransaction,
                         branchTransaction: transactions.branchTransaction,
                     });
@@ -419,12 +419,12 @@ class Tanglestash {
                 (err, bundle) => {
                     if (err || !bundle) {
                         if (err.message.includes('failed consistency check')) {
-                            reject(new TanglestashCustomErrors.NodeOutdatedError(err.message));
+                            return reject(new TanglestashCustomErrors.NodeOutdatedError(err.message));
                         } else {
-                            reject(new Error(err.message || 'No correct bundle was returned'));
+                            return reject(new Error(err.message || 'No correct bundle was returned'));
                         }
                     }
-                    resolve(bundle);
+                    return resolve(bundle);
                 });
         });
     }
@@ -442,9 +442,9 @@ class Tanglestash {
                 this.iota,
                 this.libccurl
             ).performPoW().then((result) => {
-                resolve(result);
+                return resolve(result);
             }).catch((err) => {
-                reject(err);
+                return reject(err);
             });
         });
     }
@@ -455,8 +455,8 @@ class Tanglestash {
     broadcastTransaction(transactionTrytes) {
         return new Promise((resolve, reject) => {
             this.iota.api.storeAndBroadcast(transactionTrytes, (err, output) => {
-                if (err) reject(err);
-                resolve(this.iota.utils.transactionObject(transactionTrytes[0]));
+                if (err) return reject(err);
+                return resolve(this.iota.utils.transactionObject(transactionTrytes[0]));
             });
         });
     }
@@ -526,8 +526,8 @@ class Tanglestash {
     getNewIotaAddress() {
         return new Promise((resolve, reject) => {
             this.iota.api.getNewAddress(this.seed, (err, address) => {
-                if (err) reject(new Error(err.message));
-                resolve(address);
+                if (err) return reject(new Error(err.message));
+                return resolve(address);
             });
         });
     }