From 0398de34fde8936f5f0fb74a5585ccb3a6884f41 Mon Sep 17 00:00:00 2001
From: sairajzero <sairaj0630@gmail.com>
Date: Fri, 25 Sep 2020 02:49:11 +0530
Subject: [PATCH] Migration and bug fixes

Fixed: Migration feature issues
Fixed: minor bug from previous update
---
 app/index.html | 1094 +++++++++++++++---------------------------------
 1 file changed, 336 insertions(+), 758 deletions(-)

diff --git a/app/index.html b/app/index.html
index 20dc343..4594f53 100644
--- a/app/index.html
+++ b/app/index.html
@@ -25,7 +25,7 @@
       FLO: ['https://explorer.mediciland.com/', 'https://livenet.flocha.in/', 'https://flosight.duckdns.org/', 'http://livenet-explorer.floexperiments.com'],
       FLO_TEST: ['https://testnet-flosight.duckdns.org', 'https://testnet.flocha.in/']
     },
-    SNStorageID: "FEzk75EGMPEQMrCuPosGiwuK162hcEu49E",
+    SNStorageID: "FR876VRTna3DremwQKZ421xPGMTREzctRB",
     //sendAmt: 0.001,
     //fee: 0.0005,
 
@@ -41,8 +41,9 @@
     /* List of supernode configurations (all blockchain controlled by SNStorageID)
     backupDepth     - (Interger) Number of backup nodes
     refreshDelay    - (Interger) Count of requests for triggering read-blockchain and autodelete
-    deleteDelay     - (Interger) Maximum number of duration (milliseconds) an unauthorised data is stored
+    deleteDelay     - (Interger) Maximum duration (milliseconds) an unauthorised data is stored
     errorFeedback   - (Boolean) Send error (if any) feedback to the requestor
+    delayDelta      - (Interger) Maximum allowed delay from the data-time
     */
   }
 </script>
@@ -52,52 +53,6 @@
 
 <script id="init_lib">
     //All util libraries required for Standard operations (DO NOT EDIT ANY)
-
-      /* Reactor Event handling */
-  if (typeof reactor == "undefined" || !reactor) {
-    (function () {
-      function Event(name) {
-        this.name = name;
-        this.callbacks = [];
-      }
-
-      Event.prototype.registerCallback = function (callback) {
-        this.callbacks.push(callback);
-      };
-
-      function Reactor() {
-        this.events = {};
-      }
-
-      Reactor.prototype.registerEvent = function (eventName) {
-        var event = new Event(eventName);
-        this.events[eventName] = event;
-      };
-
-      Reactor.prototype.dispatchEvent = function (eventName, eventArgs) {
-        this.events[eventName].callbacks.forEach(function (callback) {
-          callback(eventArgs);
-        });
-      };
-
-      Reactor.prototype.addEventListener = function (eventName, callback) {
-        this.events[eventName].registerCallback(callback);
-      };
-
-      window.reactor = new Reactor();
-    })();
-  }
-
-  /* Sample Usage
-    --Creating and defining the event--
-    reactor.registerEvent('<eventName>');
-    reactor.addEventListener('<eventName>', function(someObject){
-      do something...
-    });
-    --Firing the event--
-    reactor.dispatchEvent('<eventName>',<someObject>);
-  */
-
   
 /*!
 * Crypto-JS v2.5.4  Crypto.js
@@ -4941,12 +4896,12 @@ if (typeof Crypto == "undefined" || !Crypto.util) {
                     floDataCount = this.floData.length;
 
                     //flochange -- creating unique data character count logic for floData. This string is prefixed before actual floData string in Raw Transaction
-                    if (floDataCount <= 16) {
+                    if (floDataCount < 16) {
                                   floDataCountString = floDataCount.toString(16);
                                   floDataCountString = "0"+ floDataCountString;
                     } else if (floDataCount < 253) {
                                   floDataCountString = floDataCount.toString(16);
-                    } else if (floDataCount <= 1023) {
+                    } else if (floDataCount <= 1040) {
                                   floDataCountAdjusted = (floDataCount - 253) +  parseInt("0xfd00fd");
                                   floDataCountStringAdjusted = floDataCountAdjusted.toString(16);
                                   floDataCountString = floDataCountStringAdjusted.substr(0,2)+ floDataCountStringAdjusted.substr(4,2)+ floDataCountStringAdjusted.substr(2,2);
@@ -6740,290 +6695,6 @@ Bitcoin.Util = {
             exports.init();
         })(typeof module !== 'undefined' && module['exports'] ? module['exports'] : (window['shamirSecretShare'] = {}),
             typeof global !== 'undefined' ? global : window);
-
-        //For diff base
-    /*
-    Functions available:
-    diff(originalObj, updatedObj) returns the difference of the original and updated objects
-    addedDiff(original, updatedObj) returns only the values added to the updated object
-    deletedDiff(original, updatedObj) returns only the values deleted in the updated object
-    updatedDiff(original, updatedObj) returns only the values that have been changed in the updated object
-    findDifference(original, updatedObj) returns an object with the added, deleted and updated differences  
-    mergeRecurcive(original, diff) this will get you a new object that will merge all the changes between the old object and the new object
-    */
-(function(){
-    const isDate = d => d instanceof Date;
-    const isEmpty = o => Object.keys(o).length === 0;
-    const isObject = o => o != null && typeof o === 'object';
-    const properObject = o => isObject(o) && !o.hasOwnProperty ? { ...o } : o;
-    
-    
-    const getLargerArray = (l, r) => l.length > r.length ? l : r;
-    
-    const preserve = (diff, left, right) => {
-    
-      if (!isObject(diff)) return diff;
-    
-      return Object.keys(diff).reduce((acc, key) => {
-    
-        const leftArray = left[key];
-        const rightArray = right[key];
-    
-        if (Array.isArray(leftArray) && Array.isArray(rightArray)) {
-          const array = [...getLargerArray(leftArray, rightArray)];
-          return {
-            ...acc,
-            [key]: array.reduce((acc2, item, index) => {
-              if (diff[key].hasOwnProperty(index)) {
-                acc2[index] = preserve(diff[key][index], leftArray[index], rightArray[index]); // diff recurse and check for nested arrays
-                return acc2;
-              }
-    
-              delete acc2[index]; // no diff aka empty
-              return acc2;
-            }, array)
-          };
-        }
-    
-        return {
-          ...acc,
-          [key]: diff[key]
-        };
-      }, {});
-    };
-    
-    
-    const updatedDiff = (lhs, rhs) => {
-    
-      if (lhs === rhs) return {};
-    
-      if (!isObject(lhs) || !isObject(rhs)) return rhs;
-    
-      const l = properObject(lhs);
-      const r = properObject(rhs);
-    
-      if (isDate(l) || isDate(r)) {
-        if (l.valueOf() == r.valueOf()) return {};
-        return r;
-      }
-    
-      return Object.keys(r).reduce((acc, key) => {
-    
-        if (l.hasOwnProperty(key)) {
-          const difference = updatedDiff(l[key], r[key]);
-    
-          if (isObject(difference) && isEmpty(difference) && !isDate(difference)) return acc;
-    
-          return { ...acc, [key]: difference };
-        }
-    
-        return acc;
-      }, {});
-    };
-    
-    
-    const diff = (lhs, rhs) => {
-      if (lhs === rhs) return {}; // equal return no diff
-    
-      if (!isObject(lhs) || !isObject(rhs)) return rhs; // return updated rhs
-    
-      const l = properObject(lhs);
-      const r = properObject(rhs);
-    
-      const deletedValues = Object.keys(l).reduce((acc, key) => {
-        return r.hasOwnProperty(key) ? acc : { ...acc, [key]: null };
-      }, {});
-    
-      if (isDate(l) || isDate(r)) {
-        if (l.valueOf() == r.valueOf()) return {};
-        return r;
-      }
-    
-      return Object.keys(r).reduce((acc, key) => {
-        if (!l.hasOwnProperty(key)) return { ...acc, [key]: r[key] }; // return added r key
-    
-        const difference = diff(l[key], r[key]);
-    
-        if (isObject(difference) && isEmpty(difference) && !isDate(difference)) return acc; // return no diff
-    
-        return { ...acc, [key]: difference }; // return updated key
-      }, deletedValues);
-    };
-    
-    const addedDiff = (lhs, rhs) => {
-    
-      if (lhs === rhs || !isObject(lhs) || !isObject(rhs)) return {};
-    
-      const l = properObject(lhs);
-      const r = properObject(rhs);
-    
-      return Object.keys(r).reduce((acc, key) => {
-        if (l.hasOwnProperty(key)) {
-          const difference = addedDiff(l[key], r[key]);
-    
-          if (isObject(difference) && isEmpty(difference)) return acc;
-    
-          return { ...acc, [key]: difference };
-        }
-    
-        return { ...acc, [key]: r[key] };
-      }, {});
-    };
-    
-    
-    const arrayDiff = (lhs, rhs) => {
-      if (lhs === rhs) return {}; // equal return no diff
-    
-      if (!isObject(lhs) || !isObject(rhs)) return rhs; // return updated rhs
-    
-      const l = properObject(lhs);
-      const r = properObject(rhs);
-    
-      const deletedValues = Object.keys(l).reduce((acc, key) => {
-        return r.hasOwnProperty(key) ? acc : { ...acc, [key]: null };
-      }, {});
-    
-      if (isDate(l) || isDate(r)) {
-        if (l.valueOf() == r.valueOf()) return {};
-        return r;
-      }
-    
-      if (Array.isArray(r) && Array.isArray(l)) {
-        const deletedValues = l.reduce((acc, item, index) => {
-          return r.hasOwnProperty(index) ? acc.concat(item) : acc.concat(null);
-        }, []);
-    
-        return r.reduce((acc, rightItem, index) => {
-          if (!deletedValues.hasOwnProperty(index)) {
-            return acc.concat(rightItem);
-          }
-    
-          const leftItem = l[index];
-          const difference = diff(rightItem, leftItem);
-    
-          if (isObject(difference) && isEmpty(difference) && !isDate(difference)) {
-            delete acc[index];
-            return acc; // return no diff
-          }
-    
-          return acc.slice(0, index).concat(rightItem).concat(acc.slice(index + 1)); // return updated key
-        }, deletedValues);
-      }
-    
-      return Object.keys(r).reduce((acc, key) => {
-        if (!l.hasOwnProperty(key)) return { ...acc, [key]: r[key] }; // return added r key
-    
-        const difference = diff(l[key], r[key]);
-    
-        if (isObject(difference) && isEmpty(difference) && !isDate(difference)) return acc; // return no diff
-    
-        return { ...acc, [key]: difference }; // return updated key
-      }, deletedValues);
-    };
-    
-    const deletedDiff = (lhs, rhs) => {
-      if (lhs === rhs || !isObject(lhs) || !isObject(rhs)) return {};
-    
-      const l = properObject(lhs);
-      const r = properObject(rhs);
-    
-      return Object.keys(l).reduce((acc, key) => {
-        if (r.hasOwnProperty(key)) {
-          const difference = deletedDiff(l[key], r[key]);
-    
-          if (isObject(difference) && isEmpty(difference)) return acc;
-    
-          return { ...acc, [key]: difference };
-        }
-    
-        return { ...acc, [key]: null };
-      }, {});
-    };
-
-    window.findDifference = (lhs, rhs) => ({
-      added: addedDiff(lhs, rhs),
-      deleted: deletedDiff(lhs, rhs),
-      updated: updatedDiff(lhs, rhs),
-    });
-    
-    const mergeRecursive = (obj1, obj2) => {
-        for (var p in obj2) {
-            try {
-                if(obj2[p].constructor == Object) {
-                    obj1[p] = mergeRecursive(obj1[p], obj2[p]);
-                }
-                // Property in destination object set; update its value.
-                else if (Ext.isArray(obj2[p])) {
-                    // obj1[p] = [];
-                    if (obj2[p].length < 1) {
-                        obj1[p] = obj2[p];
-                    }
-                    else {
-                        obj1[p] = mergeRecursive(obj1[p], obj2[p]);
-                    }
-    
-                }else{
-                    obj1[p] = obj2[p];
-                }
-            } catch (e) {
-                // Property in destination object not set; create it and set its value.
-                obj1[p] = obj2[p];
-            }
-        }
-        return obj1;
-    }
-    
-    /*
-    var test = {
-      foo : {
-        bar : {
-          baz : null
-        }
-      },
-      bar : 1
-    };
-    cleanse(test);
-    
-    Rohit: Added a small fix for object being entered as Array*/
-    
-    const cleanse = (obj) => {
-        Object.keys(obj).forEach(key => {
-            var value = obj[key];
-            if (typeof value === "object" && value !== null) {
-                // Recurse...
-                cleanse(value);
-                // ...and remove if now "empty" (NOTE: insert your definition of "empty" here)
-                if (!Object.keys(value).length) {
-                    delete obj[key]
-                }
-            }
-            else if (value === null) {
-                // null, remove it
-                delete obj[key];
-    
-            }
-        });
-    
-    if(obj.constructor.toString().indexOf("Array") != -1)  {obj = obj.filter(function (el) {
-      return el != null;
-    });}
-    
-    return obj; 
-    }
-    
-    /*obj is original object or array, diff is the output of findDifference */
-    window.mergeDifference = (obj,diff) => {
-      if(Object.keys(diff.updated).length !== 0)
-        obj = mergeRecursive(obj,diff.updated)
-      if(Object.keys(diff.deleted).length !== 0){
-        obj = mergeRecursive(obj,diff.deleted)
-        obj = cleanse(obj)
-      }
-      if(Object.keys(diff.added).length !== 0)
-        obj = mergeRecursive(obj,diff.added)
-        return obj
-    }
-})();
 </script>
 <script>
   /*Kademlia DHT K-bucket implementation as a binary tree.*/
@@ -7640,7 +7311,7 @@ Bitcoin.Util = {
 
         //Returns flo-ID from public-key or private-key
         getFloID: function (keyHex) {
-            if(!keyHex)
+            if (!keyHex)
                 return null;
             try {
                 var key = new Bitcoin.ECKey(keyHex);
@@ -7654,7 +7325,7 @@ Bitcoin.Util = {
 
         //Verify the private-key for the given public-key or flo-ID
         verifyPrivKey: function (privateKeyHex, pubKey_floID, isfloID = true) {
-            if(!privateKeyHex || !pubKey_floID)
+            if (!privateKeyHex || !pubKey_floID)
                 return false;
             try {
                 var key = new Bitcoin.ECKey(privateKeyHex);
@@ -7674,7 +7345,7 @@ Bitcoin.Util = {
 
         //Check if the given Address is valid or not
         validateAddr: function (inpAddr) {
-            if(!inpAddr)
+            if (!inpAddr)
                 return false;
             try {
                 var addr = new Bitcoin.Address(inpAddr);
@@ -8224,8 +7895,6 @@ Bitcoin.Util = {
                         this.SNCO = superNodeList.map(sn => [this.util.distanceOf(sn, this.SNKB), sn])
                             .sort((a, b) => a[0] - b[0])
                             .map(a => a[1])
-                        console.log(this.SNCO)
-                        console.log(this.SNKB)
                         resolve('Supernode KBucket formed');
                     } catch (error) {
                         reject(error);
@@ -8257,10 +7926,10 @@ Bitcoin.Util = {
                 return oNodes
             },
 
-            prevNode: function (id, n = 1) {
+            prevNode: function (id, N = 1) {
+                let n = N || this.SNCO.length;
                 if (!this.SNCO.includes(id))
                     throw Error('Given node is not supernode');
-                if (!n) n = this.SNCO.length;
                 let pNodes = []
                 for (let i = 0, j = this.SNCO.indexOf(id) - 1; i < n; j--) {
                     if (j == this.SNCO.indexOf(id))
@@ -8269,13 +7938,13 @@ Bitcoin.Util = {
                         pNodes[i++] = this.SNCO[j]
                     else j = this.SNCO.length
                 }
-                return (n == 1 ? pNodes[0] : pNodes)
+                return (N == 1 ? pNodes[0] : pNodes)
             },
 
-            nextNode: function (id, n = 1) {
+            nextNode: function (id, N = 1) {
+                let n = N || this.SNCO.length;
                 if (!this.SNCO.includes(id))
                     throw Error('Given node is not supernode');
-                if (!n) n = this.SNCO.length;
                 let nNodes = []
                 for (let i = 0, j = this.SNCO.indexOf(id) + 1; i < n; j++) {
                     if (j == this.SNCO.indexOf(id))
@@ -8284,12 +7953,15 @@ Bitcoin.Util = {
                         nNodes[i++] = this.SNCO[j]
                     else j = -1
                 }
-                return (n == 1 ? nNodes[0] : nNodes)
+                return (N == 1 ? nNodes[0] : nNodes)
             },
 
-            closestNode: function (id, n = 1) {
-                let cNodes = this.util.closestOf(id, n).map(k => k.floID)
-                return (n == 1 ? cNodes[0] : cNodes)
+            closestNode: function (id, N = 1) {
+                let decodedId = this.util.decodeID(id);
+                let n = N || this.SNCO.length;
+                let cNodes = this.SNKB.closest(decodedId, n)
+                    .map(k => k.floID)
+                return (N == 1 ? cNodes[0] : cNodes)
             }
         },
 
@@ -8347,9 +8019,9 @@ Bitcoin.Util = {
                     this.supernodeClientWS.onmessage = (evt) => {
                         if (evt.data[0] == '$') {
                             console.log('Admin Message :', evt.data);
-                            if (evt.data == '$Access Granted!')
+                            if (evt.data == '$Access Granted')
                                 resolve("Access Granted: Initiated Supernode");
-                            else if (evt.data == '$Access Denied!')
+                            else if (evt.data == '$Access Denied')
                                 reject("Access Denied: Failed to initiate Supernode");
                             else if (evt.data == '$Access Locked')
                                 reject("Access Locked: Another instance of Supernode is active")
@@ -8371,27 +8043,40 @@ Bitcoin.Util = {
     function processIncomingData(data) {
         console.log(data);
         try {
-            let gid = evt.data.substring(0, 34);
-            let uid = evt.data.substring(35, 40);
-            let data = JSON.parse(evt.data.substring(41));
-            if (data.from in floGlobals.supernodes && data.sn_msg)
-                processTaskFromSupernode(gid, uid, data);
-            else {
-                let curTime = Date.now()
-                if(data.time > curTime + floGlobals.supernodeConfig.delayDelta || 
-                    data.time < curTime + floGlobals.supernodeConfig.delayDelta)
-                    throw Error("Time deviation longer than allowed delay");
-                else if (data.request)
-                processRequestFromUser(gid, uid, data);
-                else if (data.message)
-                    processDataFromUser(gid, uid, data);
-                else if (data.delete)
-                    processDeleteFromUser(gid, uid, data);
+            if (data[0] === '!') {
+                data = JSON.parse(data.substring(1));
+                if (data.from in floGlobals.supernodes && data.sn_msg)
+                    processTaskFromSupernode(data);
+            } else {
+                let gid = data.substring(0, 34);
+                let uid = data.substring(35, 40);
+                try {
+                    try {
+                        data = JSON.parse(data.substring(41));
+                    } catch (error) {
+                        throw Error("Invalid Data-format")
+                    }
+                    let curTime = Date.now()
+                    if (!data.time || data.time > curTime + floGlobals.supernodeConfig.delayDelta ||
+                        data.time < curTime - floGlobals.supernodeConfig.delayDelta)
+                        throw Error("Invalid Time");
+                    else if (data.request)
+                        processRequestFromUser(gid, uid, data);
+                    else if (data.message)
+                        processDataFromUser(gid, uid, data);
+                    else if (data.delete)
+                        processDeleteFromUser(gid, uid, data);
+                    else
+                        throw Error("Invalid Data-format")
+                } catch (error) {
+                    console.error(error)
+                    debugger;
+                    if (floGlobals.supernodeConfig.errorFeedback)
+                        floSupernode.supernodeClientWS.send(`@${uid}#${gid}:${error.toString()}`)
+                }
             }
         } catch (error) {
-            console.error(error)
-            if(floGlobals.supernodeConfig.errorFeedback)
-                floSupernode.supernodeClientWS.send(`@${uid}#${gid}:${error}`)
+            console.log(error)
         }
     }
 
@@ -8409,15 +8094,15 @@ Bitcoin.Util = {
             lastOnly: request.mostRecent,
             atKey: request.atVectorClock
         }
-        filterOptions.patternEval = (
+        filterOptions.patternEval = (k, v) => (
             v.application == request.application &&
             v.receiverID == request.receiverID &&
             (!request.comment || v.comment == request.comment) &&
-            (!request.type || v.type == request.type) && 
+            (!request.type || v.type == request.type) &&
             (!request.senderIDs || request.senderIDs.includes(v.senderID))
         )
         compactIDB.searchData(request.application in floGlobals.appList ? request.application :
-            floGlobals.defaultDisk, filterOptions, `SN_${closeNode}`)
+                floGlobals.defaultDisk, filterOptions, `SN_${closeNode}`)
             .then(result => floSupernode.supernodeClientWS.send(`@${uid}#${gid}:${JSON.stringify(result)}`))
             .catch(error => {
                 throw Error("Invalid request")
@@ -8431,8 +8116,10 @@ Bitcoin.Util = {
         let closeNode = floSupernode.kBucket.closestNode(data.receiverID)
         if (!floGlobals.serveList.includes(closeNode))
             throw Error("Incorrect Supernode")
+        if (!floCrypto.validateAddr(data.receiverID))
+            throw Error("Invalid senderID")
         if (data.senderID !== floCrypto.getFloID(data.pubKey))
-            throw Error("Invalid senderID/pubKey")
+            throw Error("Invalid pubKey")
         let hashcontent = ["receiverID", "time", "application", "type", "message", "comment"]
             .map(d => data[d]).join("|")
         if (!floCrypto.verifySign(hashcontent, data.sign, data.pubKey))
@@ -8468,26 +8155,26 @@ Bitcoin.Util = {
         if (data.requestorID !== floCrypto.getFloID(data.pubKey))
             throw Error("Invalid senderID/pubKey")
         let hashcontent = ["time", "application", "delete"]
-                    .map(d => data[d]).join("|")
-            throw Error("Invalid signature")
+            .map(d => data[d]).join("|")
+        throw Error("Invalid signature")
         let disk = data.application in floGlobals.appList ? data.application : floGlobals.defaultDisk;
         const deleteData = v => new Promise((res, rej) => {
             compactIDB.readData(disk, vc, `SN_${closeNode}`).then(result => {
-                if(result.receiverID === data.requestorID)
+                if (result.receiverID === data.requestorID)
                     compactIDB.removeData(disk, vc, `SN_${closeNode}`)
-                    .then(r => res(true)).catch(e => res(false))
+                    .then(r => res(vc)).catch(e => rej(vc))
                 else
-                    res(false)
-            }).catch(e => res(false))
-        }) 
-        Promise.all(data.delete.map(vc => deleteData(vc))).then(result => {
+                    rej(vc)
+            }).catch(e => rej(vc))
+        })
+        Promise.allSettled(data.delete.map(vc => deleteData(vc))).then(results => {
             floSupernode.supernodeClientWS.send(`@${uid}#${gid}:${JSON.stringify(result)}`)
-            let vectorClocks = []
-            for(let i in result)
-                if(result[i]) vectorClocks.push(data.delete[i])
+            let vectorClocks = results
+                .filter(r => r.status === 'fulfilled')
+                .map(r => r.value)
             sendBackupDelete(data.application, vectorClocks, closeNode);
         })
-        
+
     }
 </script>
 <script id="compactIDB">
@@ -8670,16 +8357,15 @@ Bitcoin.Util = {
                     curReq.onsuccess = (evt) => {
                         var cursor = evt.target.result;
                         if (cursor) {
-                            try{
-                                if(options.patternEval(cursor.primaryKey, cursor.value)){
+                            try {
+                                if (options.patternEval(cursor.primaryKey, cursor.value)) {
                                     filteredResult[cursor.primaryKey] = cursor.value;
-                                    if(options.lastOnly)    
+                                    if (options.lastOnly)
                                         return resolve(filteredResult);
                                 }
-                            }catch(error) {}
-                            finally{
+                            } catch (error) {} finally {
                                 cursor.continue();
-                            }  
+                            }
                         } else
                             resolve(filteredResult);
                     }
@@ -8717,7 +8403,7 @@ Bitcoin.Util = {
                                     console.log(result)
                                     floGlobals.serveList.push(myFloID)
                                     floGlobals.storedList.push(myFloID)
-                                    await sleep(5000);
+                                    await sleep(2000);
                                     connectToAllBackupSupernode()
                                         .then(result => console.log(result))
                                         .catch(error => console.error(error))
@@ -8862,7 +8548,7 @@ Bitcoin.Util = {
         return new Promise((resolve, reject) => {
             var snObj = {
                 lastTx: {},
-                config: {},
+                configuration: {},
                 credentials: {},
                 supernodes: {
                     indexes: {
@@ -8871,12 +8557,7 @@ Bitcoin.Util = {
                     }
                 },
                 applications: {},
-                appSubAdmins: {
-                    indexes: {
-                        app: null,
-                        subAdminID: null
-                    }
-                }
+                appSubAdmins: {}
             }
             compactIDB.setDefaultDB("SupernodeUtil")
             compactIDB.initDB("SupernodeUtil", snObj)
@@ -8892,7 +8573,7 @@ Bitcoin.Util = {
                 "type", "message", "time", "comment",
                 "pubKey", "sign"
             ];
-            let obsList = Object.keys(floGlobals.appList).push(floGlobals.defaultDisk)
+            let obsList = Object.keys(floGlobals.appList).concat(floGlobals.defaultDisk)
             var idbObj = {}
             for (let d of obsList) {
                 idbObj[d] = {
@@ -8913,7 +8594,7 @@ Bitcoin.Util = {
         refreshBlockchainData().then(result => {
             console.log(result)
             diskCleanUp()
-                .then(result => console.log(result))
+                .then(result => console.info(result))
                 .catch(error => console.error(error))
         }).catch(error => console.error(error))
     }
@@ -8924,27 +8605,32 @@ Bitcoin.Util = {
             const filterDelete = (obs, db, filter) => {
                 return new Promise((res, rej) => {
                     compactIDB.searchData(obs, filter, db).then(results => {
-                        for(let k in results)
-                            compactIDB.removeData(obs, k, db)
-                        res(true)
-                    })
+                        Promise.allSettled(Object.keys(results)
+                            .map(k => compactIDB.removeData(obs, k, db))
+                        ).then(r => res(obs))
+                    }).catch(e => rej(obs))
                 })
             }
             var promises = []
             //For authorised-apps data
-            for(let app in floGlobals.appList){
+            for (let app in floGlobals.appList) {
                 const patternEval = (k, v) => (floGlobals.appList[app] != v.receiverID ||
-                    (!floGlobals.appSubAdmins[app].includes(v.senderID) && 
-                    floGlobals.appList[app] != v.senderID))
-                for(let sn of  floGlobals.storedList)
-                    promises.push(filterDelete(app, `SN_${sn}`, {upperKey, patternEval}))
+                    (!floGlobals.appSubAdmins[app].includes(v.senderID) &&
+                        floGlobals.appList[app] != v.senderID))
+                for (let sn of floGlobals.storedList)
+                    promises.push(filterDelete(app, `SN_${sn}`, {
+                        upperKey,
+                        patternEval
+                    }))
             }
             //For all other-apps data
-            for(let sn of  floGlobals.storedList)
-                promises.push(filterDelete(floGlobals.defaultDisk, `SN_${sn}`, {upperKey}))
-            Promise.all(promises).then(results => {
-                resolve(`Auto-delete successful from ${deleteStart} to ${deleteEnd}`)
-            }).catch(error => reject(error))
+            for (let sn of floGlobals.storedList)
+                promises.push(filterDelete(floGlobals.defaultDisk, `SN_${sn}`, {
+                    upperKey
+                }))
+            Promise.allSettled(promises).then(results => {
+                resolve(`Disk Cleanup finished: ${upperKey}`)
+            })
         })
     }
 
@@ -8971,57 +8657,67 @@ Bitcoin.Util = {
                     pattern: "SuperNodeStorage"
                 }).then(result => {
                     let promises = []
-                    let newNodes = [], delNodes = [];
-                    let newApps = [], delApps = [];
+                    let newNodes = [],
+                        delNodes = [];
+                    let newApps = [],
+                        delApps = [];
 
                     for (var i = result.data.length - 1; i >= 0; i--) {
                         var content = JSON.parse(result.data[i]).SuperNodeStorage;
-                        for (let sn of content.removeNodes) {
-                            promises.push(compactIDB.removeData("supernodes", sn))
-                            if(newNodes.includes(sn)){
-                                let i = newNodes.indexOf(sn)
-                                newNodes.splice(i, 1)
-                            } else delNodes.push(sn)
-                        }
-                        for (sn in content.newNodes) {
-                            promises.push(compactIDB.writeData("supernodes", content
-                                .newNodes[sn], sn))
-                            if(delNodes.includes(sn)){
-                                let i = delNodes.indexOf(sn)
-                                delNodes.splice(i, 1)
-                            } else newNodes.push(sn)
-                        }
-                        for (c in content.config)
-                            promises.push(compactIDB.writeData("configuration", content
-                                .config[c], c))
-                        for(let app of content.removeApps){
-                            promises.push(compactIDB.removeData("applications", app))
-                            if(newApps.includes(sn)){
-                                let i = newApps.indexOf(sn)
-                                newApps.splice(i, 1)
-                            } else delApps.push(sn)
-                        }
-                        for (let app in content.addApps){
-                            promises.push(compactIDB.writeData("applications",
-                                content.application[app], app))
-                            if(delApps.includes(sn)){
-                                let i = delApps.indexOf(sn)
-                                delApps.splice(i, 1)
-                            } else newApps.push(sn)
-                        }
+                        if (content.removeNodes)
+                            for (let sn of content.removeNodes) {
+                                promises.push(compactIDB.removeData("supernodes", sn))
+                                if (newNodes.includes(sn)) {
+                                    let i = newNodes.indexOf(sn)
+                                    newNodes.splice(i, 1)
+                                } else delNodes.push(sn)
+                            }
+                        if (content.newNodes)
+                            for (sn in content.newNodes) {
+                                promises.push(compactIDB.writeData("supernodes", content
+                                    .newNodes[sn], sn))
+                                if (delNodes.includes(sn)) {
+                                    let i = delNodes.indexOf(sn)
+                                    delNodes.splice(i, 1)
+                                } else newNodes.push(sn)
+                            }
+                        if (content.config)
+                            for (c in content.config)
+                                promises.push(compactIDB.writeData("configuration", content
+                                    .config[c], c))
+                        if (content.removeApps)
+                            for (let app of content.removeApps) {
+                                promises.push(compactIDB.removeData("applications", app))
+                                if (newApps.includes(sn)) {
+                                    let i = newApps.indexOf(sn)
+                                    newApps.splice(i, 1)
+                                } else delApps.push(sn)
+                            }
+                        if (content.addApps)
+                            for (let app in content.addApps) {
+                                promises.push(compactIDB.writeData("applications",
+                                    content.application[app], app))
+                                if (delApps.includes(sn)) {
+                                    let i = delApps.indexOf(sn)
+                                    delApps.splice(i, 1)
+                                } else newApps.push(sn)
+                            }
                     }
 
                     compactIDB.writeData("lastTx", result.totalTxs, floGlobals.SNStorageID);
                     Promise.all(promises).then(results => {
                         readDataFromIDB().then(result => {
-                                updateAppDisk(newApps, delApps).then(result => {
-                                    console.log(result)
-                                    migrateData(newNodes, delNodes, flag).then(
-                                    result => {
-                                        console.info(result)
-                                        resolve(`Updated Supernode Configuration`)
-                                    }).catch(error => reject(error))
-                                }).catch(error => reject(error))
+                            updateAppDisk(newApps, delApps).then(result => {
+                                console.log(result)
+                                migrateData(newNodes, delNodes, flag)
+                                    .then(
+                                        result => {
+                                            console.info(result)
+                                            resolve(
+                                                `Updated Supernode Configuration`
+                                                )
+                                        }).catch(error => reject(error))
+                            }).catch(error => reject(error))
                         }).catch(error => reject(error))
                     }).catch(error => reject(error))
                 }).catch(error => reject(error))
@@ -9103,7 +8799,34 @@ Bitcoin.Util = {
     }
 
     /*Supernode Backup and migration functions*/
-    function connectToAllBackupSupernode(curNode = myFloID, i = 0) {
+
+    function connectToAllBackupSupernode() {
+        return new Promise((resolve, reject) => {
+            connectToBackupSupernode()
+                .then(result => resolve(result))
+                .catch(error => reject(error))
+                .finally(_ => {
+                    if (floGlobals.backupNodes.length) {
+                        let innerNodes = floSupernode.kBucket.innerNodes(myFloID, floGlobals.backupNodes[0]
+                            .floID)
+                        var data = {
+                            from: myFloID,
+                            sn_msg: {
+                                type: "startBackupServe",
+                                time: Date.now()
+                            }
+                        }
+                        innerNodes.forEach(sn => {
+                            data.sn_msg.snID = sn;
+                            data.sign = floCrypto.signData(JSON.stringify(data.sn_msg), myPrivKey);
+                            floGlobals.backupNodes[0].wsConn.send('!' + JSON.stringify(data))
+                        })
+                    }
+                })
+        })
+    }
+
+    function connectToBackupSupernode(curNode = myFloID, i = 0) {
         return new Promise((resolve, reject) => {
             if (floGlobals.backupNodes.length > i) {
                 let rmNodes = floGlobals.backupNodes.splice(i, floGlobals.backupNodes.length);
@@ -9124,7 +8847,7 @@ Bitcoin.Util = {
                             flag = true;
                         }).catch(error => console.error(error))
                         .finally(_ => {
-                            connectToAllBackupSupernode(nxtNode, flag ? i + 1 : i)
+                            connectToBackupSupernode(nxtNode, flag ? i + 1 : i)
                                 .then(result => resolve(result))
                                 .catch(error => reject(error))
                         })
@@ -9165,7 +8888,7 @@ Bitcoin.Util = {
         floGlobals.backupNodes.splice(index, 1);
         //connect to next node available
         var len = floGlobals.backupNodes.length
-        connectToAllBackupSupernode(len == 0 ? offlineNodeID : floGlobals.backupNodes[len - 1], len).then(result => {
+        connectToBackupSupernode(len == 0 ? offlineNodeID : floGlobals.backupNodes[len - 1], len).then(result => {
                 console.log(result)
                 //inform the newly connected node to store backups of all serving
                 for (let sn of floGlobals.serveList) {
@@ -9178,7 +8901,7 @@ Bitcoin.Util = {
                         }
                     }
                     sendData.sign = floCrypto.signData(JSON.stringify(sendData.sn_msg), myPrivKey)
-                    floGlobals.backupNodes[len].wsConn.send(JSON.stringify(sendData))
+                    floGlobals.backupNodes[len].wsConn.send('!' + JSON.stringify(sendData))
                 }
             }).catch(error => console.error(error))
             .finally(_ => {
@@ -9199,19 +8922,22 @@ Bitcoin.Util = {
                             }
                         }
                         sendData.sign = floCrypto.signData(JSON.stringify(sendData.sn_msg), myPrivKey)
-                        floGlobals.backupNodes[0].wsConn.send(JSON.stringify(sendData))
+                        floGlobals.backupNodes[0].wsConn.send('!' + JSON.stringify(sendData))
                     }
                 }
             })
     }
 
-    function processTaskFromSupernode(gid, uid, data) {
+    function processTaskFromSupernode(data) {
         if (floCrypto.verifySign(JSON.stringify(data.sn_msg), data.sign, floGlobals.supernodes[data.from].pubKey)) {
             //Backup event messages (most crucial part)
             switch (data.sn_msg.type) {
                 case "backupData":
                     storeBackupData(data.sn_msg)
                     break;
+                case "migratedData":
+                    storeMigratedData(data.sn_msg)
+                    break;
                 case "backupDelete":
                     deleteBackupData(data.sn_msg)
                     break;
@@ -9230,47 +8956,62 @@ Bitcoin.Util = {
                 case "stopBackupStore":
                     stopBackupStore(data.sn_msg.snID)
                     break;
-                case "reconstructBackupStore":
-                    reconstructBackupStore(data.sn_msg.snID, data.from)
-                    break;
-                case "initateReconstruct":
-                    initateReconstruct(data.sn_msg.snID)
-                    break;
-                case "iniateRefresh":
-                    iniateRefresh()
+                case "initiateRefresh":
+                    initiateRefresh()
                     break;
                 case "dataRequest":
                     sendStoredData(data.sn_msg.snID, data.from, data.sn_msg.lowerKey)
                     break;
                 case "dataSync":
                     dataSyncIndication(data.sn_msg.snID, data.sn_msg.mode, data.from)
+                    break;
                 default:
                     console.log(data.sn_msg)
             }
         }
     }
 
-    function sendDataToBackupNodes(sn_msg) {
+    function sendToBackupNodes(sn_msg) {
         var data = {
             from: myFloID,
             sn_msg: sn_msg,
             sign: floCrypto.signData(JSON.stringify(sn_msg), myPrivKey)
         }
         for (let node of floGlobals.backupNodes)
-            node.wsConn.send(JSON.stringify(data))
+            node.wsConn.send('!' + JSON.stringify(data))
     }
 
-    function sendDataToSupernode(receiver, sn_msg) {
-        floSupernode.connect(receiver).then(node => {
+    function sendToSupernode(receiver, sn_msg, direct = true) {
+        ((direct ? floSupernode.connect(receiver) : floSupernode.connectActive(receiver)))
+        .then(node => {
             var data = {
                 from: myFloID,
                 sn_msg: sn_msg,
                 sign: floCrypto.signData(JSON.stringify(sn_msg), myPrivKey)
             }
-            node.send(JSON.stringify(data));
+            node.send('!' + JSON.stringify(data));
         }).catch(error => console.error(error))
     }
 
+    function sendToAllSupernodes(sn_msg, log = false) {
+        var data = {
+            from: myFloID,
+            sn_msg: sn_msg,
+            sign: floCrypto.signData(JSON.stringify(sn_msg), myPrivKey)
+        }
+        let dataStr = JSON.stringify(data)
+        for (let sn in floGlobals.supernodes) {
+            if (sn !== myFloID) {
+                floSupernode.connect(sn)
+                    .then(node => {
+                        node.send('!' + dataStr);
+                        node.close();
+                        if (log) console.info('Indicated:' + sn)
+                    }).catch(error => console.error(error))
+            }
+        }
+    }
+
     function sendBackupData(key, value, snID) {
         var sn_msg = {
             type: "backupData",
@@ -9279,10 +9020,10 @@ Bitcoin.Util = {
             key: key,
             value: value
         }
-        sendDataToBackupNodes(sn_msg);
+        sendToBackupNodes(sn_msg);
     }
 
-    function sendBackupDelete(application, vectorClocks, snID){
+    function sendBackupDelete(application, vectorClocks, snID) {
         var sn_msg = {
             type: "backupDelete",
             snID: snID,
@@ -9290,37 +9031,35 @@ Bitcoin.Util = {
             application: application,
             vectorClocks: vectorClocks
         }
-        sendDataToBackupNodes(sn_msg);
+        sendToBackupNodes(sn_msg);
     }
 
     function sendStoredData(snID, receiver, lowerKey) {
         if (typeof lowerKey != "object") lowerKey = {};
-        const sendObs = (obs, node) => {
-            return new Promise((res, rej) => {
-                compactIDB.searchData(obs, {
-                        lowerKey: lowerKey[obs]
-                    }`SN_${snID}`).then(result => {
-                        for (let k in result) {
-                            var data = {
-                                from: myFloID,
-                                sn_msg: {
-                                    type: "backupData",
-                                    snID: snID,
-                                    time: Date.now(),
-                                    key: k,
-                                    value: result[k]
-                                }
-                            }
-                            data.sign = floCrypto.signData(JSON.stringify(data.sn_msg), myPrivKey)
-                            node.send(JSON.stringify(data));
+        const sendObs = (obs, node) => new Promise((res, rej) => {
+            compactIDB.searchData(obs, {
+                lowerKey: lowerKey[obs]
+            }, `SN_${snID}`).then(result => {
+                for (let k in result) {
+                    var data = {
+                        from: myFloID,
+                        sn_msg: {
+                            type: "backupData",
+                            snID: snID,
+                            time: Date.now(),
+                            key: k,
+                            value: result[k]
                         }
-                    }).catch(error => console.error(error))
-                    .finally(res(true))
-            })
-        };
+                    }
+                    data.sign = floCrypto.signData(JSON.stringify(data.sn_msg), myPrivKey)
+                    node.send('!' + JSON.stringify(data));
+                }
+                res(obs)
+            }).catch(error => rej(error))
+        })
         if (floGlobals.storedList.includes(snID)) {
             floSupernode.connect(receiver).then(node => {
-                let obsList = Object.keys(floGlobals.appList).push(floGlobals.defaultDisk)
+                let obsList = Object.keys(floGlobals.appList).concat(floGlobals.defaultDisk)
                 console.info(`START: ${snID} data sync(send) to ${receiver}`)
                 var data = {
                     from: myFloID,
@@ -9332,12 +9071,12 @@ Bitcoin.Util = {
                     }
                 }
                 data.sign = floCrypto.signData(JSON.stringify(data.sn_msg), myPrivKey)
-                node.send(JSON.stringify(data));
-                Promise.all(obsList.map(o => sendObs(o, node))).then(result => {
+                node.send('!' + JSON.stringify(data));
+                Promise.allSettled(obsList.map(o => sendObs(o, node))).then(result => {
                     data.sn_msg.mode = "END";
                     data.sn_msg.time = Date.now();
                     data.sign = floCrypto.signData(JSON.stringify(data.sn_msg), myPrivKey)
-                    node.send(JSON.stringify(data));
+                    node.send('!' + JSON.stringify(data));
                     console.info(`END: ${snID} data sync(send) to ${receiver}`)
                 })
             }).catch(error => console.error(error))
@@ -9350,7 +9089,7 @@ Bitcoin.Util = {
 
     function requestBackupData(from, snID) {
         var promises = []
-        let obsList = Object.keys(floGlobals.appList).push(floGlobals.defaultDisk)
+        let obsList = Object.keys(floGlobals.appList).concat(floGlobals.defaultDisk)
         for (let i in obsList)
             promises[i] = compactIDB.searchData(obsList[i], {
                 lastOnly: true
@@ -9358,14 +9097,14 @@ Bitcoin.Util = {
         Promise.all(promises).then(results => {
             var lowerKey = {}
             for (let i in results)
-                lowerKey[obsList[i]] = Object.keys(results[i]).sort().pop()
+                lowerKey[obsList[i]] = Object.keys(results[i]).sort().pop() + 1
             var sn_msg = {
                 type: "dataRequest",
                 snID: snID,
                 lowerKey: lowerKey,
                 time: Date.now()
             }
-            sendDataToSupernode(from, sn_msg)
+            sendToSupernode(from, sn_msg, true)
         })
     }
 
@@ -9373,14 +9112,25 @@ Bitcoin.Util = {
         if (floGlobals.storedList.includes(data.snID) &&
             floSupernode.kBucket.closestNode(data.value.receiverID) === data.snID) {
             compactIDB.addData(
-                data.value.application in floGlobals.appList ? data.value.application : 
+                data.value.application in floGlobals.appList ? data.value.application :
                 floGlobals.defaultDisk, data.value, data.key, `SN_${data.snID}`
             )
         }
     }
 
+    function storeMigratedData(data) {
+        if (floGlobals.serveList.includes(data.snID) &&
+            floSupernode.kBucket.closestNode(data.value.receiverID) === data.snID) {
+            compactIDB.addData(
+                data.value.application in floGlobals.appList ? data.value.application :
+                floGlobals.defaultDisk, data.value, data.key, `SN_${data.snID}`
+            )
+            sendBackupData(data.key, data.value, data.snID)
+        }
+    }
+
     function deleteBackupData(data) {
-        if (floGlobals.storedList.includes(data.snID)){
+        if (floGlobals.storedList.includes(data.snID)) {
             let disk = data.application in floGlobals.appList ? data.application : floGlobals.defaultDisk;
             data.vectorClocks.forEach(vc => compactIDB.removeData(disk, vc, `SN_${data.snID}`))
         }
@@ -9390,39 +9140,23 @@ Bitcoin.Util = {
         console.log("Indicating supernode is up")
         if (floGlobals.backupNodes.length) {
             //inform all other nodes
-            var data = {
-                from: myFloID,
-                sn_msg: {
-                    type: "supernodeUp",
-                    time: Date.now()
-                }
-            }
-            data.sign = floCrypto.signData(JSON.stringify(data.sn_msg), myPrivKey)
-            let dataStr = JSON.stringify(data)
-            for (let sn in floGlobals.supernodes) {
-                if (sn !== myFloID) {
-                    floSupernode.connect(sn)
-                        .then(node => {
-                            node.send(dataStr);
-                            console.info('Indicated:' + sn)
-                            node.close();
-                        }).catch(error => console.error(error))
-                }
+            var sn_msg = {
+                type: "supernodeUp",
+                time: Date.now()
             }
+            sendToAllSupernodes(sn_msg, true)
             //Inform backup nodes to store self
             var sn_msg = {
                 type: "startBackupStore",
                 snID: myFloID,
                 time: Date.now()
             }
-            sendDataToBackupNodes(sn_msg)
+            sendToBackupNodes(sn_msg)
             //request self data from backup
             requestBackupData(floGlobals.backupNodes[0].floID, myFloID)
         } else {
-            let nodeList = floSupernode.kBucket.prevNode(myFloID, floSupernode.kBucket.SNKB.toArray()
-                .length - 1)
-            for (sn of nodeList) {
-                startBackupStore(sn);
+            let nodeList = floSupernode.kBucket.prevNode(myFloID, null)
+            for (let sn of nodeList) {
                 startBackupServe(sn);
             }
         }
@@ -9447,10 +9181,10 @@ Bitcoin.Util = {
                         data.sn_msg.snID = sn;
                         data.sn_msg.type = "startBackupStore";
                         data.sign = floCrypto.signData(JSON.stringify(data.sn_msg), myPrivKey);
-                        node.send(JSON.stringify(data))
+                        node.send('!' + JSON.stringify(data))
                         data.sn_msg.type = "startBackupServe";
                         data.sign = floCrypto.signData(JSON.stringify(data.sn_msg), myPrivKey);
-                        node.send(JSON.stringify(data))
+                        node.send('!' + JSON.stringify(data))
                         stopBackupServe(sn);
                     }
                 }
@@ -9458,8 +9192,7 @@ Bitcoin.Util = {
 
             if (floGlobals.backupNodes.length < floGlobals.supernodeConfig.backupDepth) {
                 //when less supernodes available, just connect to the revived node
-                let nxtNodes = floSupernode.kBucket.nextNode(myFloID, floSupernode.kBucket.SNKB
-                    .toArray().length)
+                let nxtNodes = floSupernode.kBucket.nextNode(myFloID, null)
                 var index = floGlobals.backupNodes.length
                 for (let i in floGlobals.backupNodes) {
                     if (snID == floGlobals.backupNodes[i].floID) { //revived node is already connected
@@ -9480,15 +9213,13 @@ Bitcoin.Util = {
                         for (let sn of floGlobals.serveList) {
                             data.sn_msg.snID = sn;
                             data.sign = floCrypto.signData(JSON.stringify(data.sn_msg), myPrivKey);
-                            node.send(JSON.stringify(data))
+                            node.send('!' + JSON.stringify(data))
                         }
                     }).catch(error => console.error(error))
                 }
             } else {
                 //connect to the revived node as backup if needed
-                let nxtNodes = floSupernode.kBucket.nextNode(myFloID, floSupernode.kBucket.SNKB
-                    .toArray()
-                    .length)
+                let nxtNodes = floSupernode.kBucket.nextNode(myFloID, null)
                 var index = false
                 for (let i in floGlobals.backupNodes) {
                     if (snID == floGlobals.backupNodes[i].floID) //revived node is already connected
@@ -9509,10 +9240,11 @@ Bitcoin.Util = {
                             data.sn_msg.snID = sn;
                             data.sn_msg.type = "startBackupStore";
                             data.sign = floCrypto.signData(JSON.stringify(data.sn_msg), myPrivKey);
-                            node.send(JSON.stringify(data)) //start for connected backup node
+                            node.send('!' + JSON.stringify(data)) //start for connected backup node
                             data.sn_msg.type = "stopBackupStore";
                             data.sign = floCrypto.signData(JSON.stringify(data.sn_msg), myPrivKey);
-                            rmNode.wsConn.send(JSON.stringify(data)) //stop for removed backup node
+                            rmNode.wsConn.send('!' + JSON.stringify(
+                                data)) //stop for removed backup node
                         }
 
                     }).catch(error => console.error(error))
@@ -9523,14 +9255,15 @@ Bitcoin.Util = {
 
     function startBackupServe(snID) {
         //start serving the dead node
-        if (!floGlobals.serveList.includes(snID)) {
+        if (!floGlobals.serveList.includes(snID) && snID in floGlobals.supernodes) {
+            startBackupStore(snID)
             floGlobals.serveList.push(snID)
             let sn_msg = {
                 type: "startBackupStore",
                 snID: snID,
                 time: Date.now()
             }
-            sendDataToBackupNodes(sn_msg);
+            sendToBackupNodes(sn_msg);
             console.warn("BackupServe started for " + snID);
         }
     }
@@ -9542,7 +9275,7 @@ Bitcoin.Util = {
             if (floGlobals.backupNodes.length == floGlobals.supernodeConfig.backupDepth) {
                 //indicate the last backup node to stop storing the revived's backup
                 var lastIndex = floGlobals.backupNodes.length - 1
-                if (lastIndex !== -1) {
+                if (lastIndex === floGlobals.supernodeConfig.backupDepth - 1) {
                     var data = {
                         from: myFloID,
                         sn_msg: {
@@ -9552,7 +9285,7 @@ Bitcoin.Util = {
                         }
                     }
                     data.sign = floCrypto.signData(JSON.stringify(data.sn_msg), myPrivKey)
-                    floGlobals.backupNodes[lastIndex].wsConn.send(JSON.stringify(data))
+                    floGlobals.backupNodes[lastIndex].wsConn.send('!' + JSON.stringify(data))
                 }
             }
             console.warn("BackupServe stopped for " + snID);
@@ -9560,7 +9293,7 @@ Bitcoin.Util = {
     }
 
     function startBackupStore(snID, from = null) {
-        if (!floGlobals.storedList.includes(snID)) {
+        if (!floGlobals.storedList.includes(snID) && snID in floGlobals.supernodes) {
             floGlobals.storedList.push(snID)
             initIndexedDBforSupernodeDataStorage(snID).then(result => {
                 if (from)
@@ -9589,242 +9322,87 @@ Bitcoin.Util = {
                     .then(result => console.log(result))
                     .catch(error => console.error(error))
                     .finally(async _ => {
-                        await sleep(300000);
-                        newNodes.forEach(node => {
-                            //transfer data to new node if required
-                            let prevNode = floSupernode.kBucket.prevNode(node);
-                            if (floGlobals.serveList.includes(prevNode))
-                                transferData(prevNode, node)
-                            let nextNode = floSupernode.kBucket.nextNode(node);
-                            if (floGlobals.serveList.includes(nextNode))
-                                transferData(nextNode, node)
+                        debugger; //await sleep(300000);
+                        recalcClosestNode().then(result => {
+                            delNodes.filter(x => floGlobals.serveList.includes(x))
+                                .forEach(sn => {
+                                    let sn_msg = {
+                                        type: "stopBackupStore",
+                                        snID: sn,
+                                        time: Date.now()
+                                    }
+                                    sendToBackupNodes(sn_msg)
+                                    stopBackupServe(sn)
+                                })
+                            resolve("Data migration completed")
                         })
-                        delNodes.forEach(node => {
-                            //split the data to its prev and next nodes
-                            let KB = floSupernode.kBucket.constructKB(Object.keys(
-                                floGlobals
-                                .supernodes).concat(node).sort());
-                            let prevNode = floSupernode.kBucket.prevNode(node, 1, KB);
-                            let nextNode = floSupernode.kBucket.nextNode(node, 1, KB);
-                            if (floGlobals.serveList.includes(nextNode))
-                                splitData(node, prevNode, nextNode);
-                        })
-                        resolve("Data migration")
                     })
             }).catch(error => reject(error))
         })
     }
 
+    function recalcClosestNode() {
+        let obsList = Object.keys(floGlobals.appList).concat(floGlobals.defaultDisk)
+        const recalcObsData = (obs, snID, filter) => new Promise((res, rej) => {
+            let db = `SN_${snID}`
+            compactIDB.searchData(obs, filter, db).then(result => {
+                for (let d in result) {
+                    let closest = floSupernode.kBucket.closestNode(result[d].receiverID);
+                    var sn_msg = {
+                        type: "migratedData",
+                        snID: closest,
+                        key: d,
+                        value: result[d]
+                    }
+                    sendToSupernode(closest, sn_msg, false);
+                    compactIDB.removeData(obs, d, db);
+                }
+                sendBackupDelete(obs, Object.keys(result), snID)
+                res(true)
+            }).catch(error => rej(error))
+        });
+        const recalcDatabase = (snID) => {
+            let filter = {
+                patternEval: (k, v) => floSupernode.kBucket.closestNode(v.senderID) != snID
+            }
+            return Promise.allSettled(
+                obsList.map(o => recalcObsData(o, snID, filter)));
+        }
+        return Promise.all(floGlobals.serveList.map(sn => recalcDatabase(sn)));
+    }
+
     function intimateNodes(flag) {
         if (!flag) //skip intimate if already intimated
             return;
         //intimate all nodes that there is change in supernode list
-        var data = {
-            from: myFloID,
-            sn_msg: {
-                type: "iniateRefresh",
-                time: Date.now()
-            }
-        }
-        data.sign = floCrypto.signData(JSON.stringify(data.sn_msg), myPrivKey)
-        let dataStr = JSON.stringify(data)
-        for (let sn in floGlobals.supernodes) {
-            if (sn !== myFloID) {
-                floSupernode.connect(sn)
-                    .then(node => {
-                        node.send(dataStr);
-                        node.close();
-                    }).catch(error => console.error(error))
-            }
+        var sn_msg = {
+            type: "initiateRefresh",
+            time: Date.now()
         }
+        sendToAllSupernodes(sn_msg)
     }
 
-    function iniateRefresh() {
+    function initiateRefresh() {
         readSupernodeConfigFromAPI(false)
             .then(result => console.log(result))
             .catch(error => console.error(error))
     }
 
-    function transferData(snID, toID) {
-        //tranfer data from snID to toID if required
-        floSupernode.connectActive(toID).then(async node => {
-            const transferObs = function (obs) {
-                return new Promise((res, rej) => {
-                    compactIDB.readAllData(obs, `SN_${snID}`).then(result => {
-                        let promises = []
-                        for (let k in result) {
-                            if (floSupernode.kBucket.closestNode(result[k]
-                                .receiverID) ===
-                                toID) {
-                                var data = {
-                                    from: myFloID,
-                                    sn_msg: {
-                                        type: "backupData",
-                                        snID: toID,
-                                        time: Date.now(),
-                                        key: k,
-                                        value: result[k]
-                                    }
-                                }
-                                data.sign = floCrypto.signData(JSON.stringify(data
-                                        .sn_msg),
-                                    myPrivKey)
-                                node.send(JSON.stringify(data));
-                                promises.push(compactIDB.removeData(obs, k,
-                                    `SN_${snID}`))
-                            }
-                        }
-                        Promise.all(promises).then(r => null).catch(e => null)
-                            .finally(_ => res(true))
-                    }).catch(error => console.error(error))
-                })
-            }
-            //indicate receiver to start storing toID (if already not)
-            let data = {
-                from: myFloID,
-                sn_msg: {
-                    type: "startBackupStore",
-                    snID: toID,
-                    time: Date.now()
-                }
-            }
-            data.sign = floCrypto.signData(JSON.stringify(data.sn_msg), myPrivKey)
-            node.send(JSON.stringify(data));
-            data.sn_msg.type = "startBackupServe";
-            data.sign = floCrypto.signData(JSON.stringify(data.sn_msg), myPrivKey)
-            node.send(JSON.stringify(data));
-            await sleep(5000);
-            //process all data for sending
-            let obsList = Object.keys(floGlobals.appList).push(floGlobals.defaultDisk)
-            Promise.all(obsList.map(obs => transferObs(obs))).then(result => {
-                node.close();
-                //initiate reconstruct phase
-                let sn_msg = {
-                    type: "reconstructBackupStore",
-                    snID: snID,
-                    time: Date.now()
-                }
-                sendDataToBackupNodes(sn_msg)
-            })
-        }).catch(error => console.error(error))
-    }
 
-    function splitData(snID, prev, next) {
-        //split data of snID to prev and next
-        floSupernode.connectActive(prev).then(async node => {
-            const splitObs = function (obs) {
-                return new Promise((res, rej) => {
-                    compactIDB.readAllData(obs, `SN_${snID}`).then(result => {
-                        let promises = []
-                        for (let k in result) {
-                            if (floSupernode.kBucket.closestNode(result[k]
-                                .receiverID) ===
-                                prev) {
-                                var data = {
-                                    from: myFloID,
-                                    sn_msg: {
-                                        type: "backupData",
-                                        snID: prev,
-                                        time: Date.now(),
-                                        key: k,
-                                        value: result[k]
-                                    }
-                                }
-                                data.sign = floCrypto.signData(JSON.stringify(data
-                                        .sn_msg),
-                                    myPrivKey)
-                                node.send(JSON.stringify(data));
-                            } else
-                                promises.push(compactIDB.addData(obs, result[k], k,
-                                    `SN_${next}`))
-                        }
-                        Promise.all(promises).then(r => null).catch(e => null)
-                            .finally(_ => res(true))
-                    }).catch(error => console.error(error))
-                })
-            }
-            //indicate receiver to start storing toID (if already not)
-            let data = {
-                from: myFloID,
-                sn_msg: {
-                    type: "startBackupStore",
-                    snID: prev,
-                    time: Date.now()
-                }
-            }
-            data.sign = floCrypto.signData(JSON.stringify(data.sn_msg), myPrivKey)
-            node.send(JSON.stringify(data));
-            data.sn_msg.type = "startBackupServe";
-            data.sign = floCrypto.signData(JSON.stringify(data.sn_msg), myPrivKey)
-            node.send(JSON.stringify(data));
-            await sleep(5000);
-            //process all data for split (and send data to prev if needed)
-            let obsList = Object.keys(floGlobals.appList).push(floGlobals.defaultDisk)
-            Promise.all(obsList.map(obs => splitObs(obs))).then(result => {
-                //initiate reconstruct phase
-                let sn_msg = {
-                    type: "reconstructBackupStore",
-                    snID: next,
-                    time: Date.now()
-                }
-                sendDataToBackupNodes(sn_msg);
-                //indicate prev to initiate reconstruct phase
-                var sn_data = {
-                    from: myFloID,
-                    sn_msg: {
-                        type: "initateReconstruct",
-                        snID: prev,
-                        time: Date.now()
-                    }
-                }
-                sn_data.sign = floCrypto.signData(JSON.stringify(sn_data.sn_msg), myPrivKey)
-                node.send(JSON.stringify(sn_data));
-                node.close();
-            })
-        }).catch(error => console.error(error))
-    }
-
-    function reconstructBackupStore(snID, from) {
-        let obsList = Object.keys(floGlobals.appList).push(floGlobals.defaultDisk)
-        Promise.all(obsList.map(obs => compactIDB.clearData(obs, `SN_${snID}`)))
-            .then(results => {
-                var sn_msg = {
-                    type: "dataRequest",
-                    snID: snID,
-                    lowerKey: {},
-                    time: Date.now()
-                }
-                sendDataToSupernode(from, sn_msg)
-            })
-    }
-
-    function initateReconstruct(snID) {
-        if (floGlobals.serveList.includes(snID)) {
-            let sn_msg = {
-                type: "reconstructBackupStore",
-                snID: snID,
-                time: Date.now()
-            }
-            sendDataToBackupNodes(sn_msg);
-        }
-    }
-</script>
-<script>
     function updateAppDisk(newApps, delApps) {
         return new Promise((resolve, reject) => {
-            if(!newApps.length && !delApps.length)
+            if (!newApps.length && !delApps.length)
                 return resolve('No need for app disk update')
             const transfer = (from, to, filter, db) => {
-                return new Promise((res, rej) => {
+                return new Promise(res => {
                     (filter ? compactIDB.searchData(from, filter, db) :
-                        compactIDB.readAllData(from, db)).then(results => {
+                        compactIDB.readAllData(from, db)).then(result => {
                         let promises = [];
                         for (let k in result) {
                             promises.push(compactIDB.writeData(to, result[k], k, db))
                             promises.push(compactIDB.removeData(from, k, db))
                         }
-                        Promise.all(promises).then(r => null).catch(e => null)
-                            .finally(_ => res(true))
+                        Promise.allSettled(promises).then(r => res(true))
                     })
                 })
             };
@@ -9834,7 +9412,7 @@ Bitcoin.Util = {
                 Promise.all(floGlobals.storedList.map(sn => initIndexedDBforSupernodeDataStorage(sn)));
             const unauthoriseApps = (apps) =>
                 Promise.all(apps.map(a => transferObs(a, floGlobals.defaultDisk, null))
-                .push(rmSubAdminList(apps)));
+                    .push(rmSubAdminList(apps)));
             const authoriseApps = (apps) =>
                 Promise.all(apps.map(a => transferObs(floGlobals.defaultDisk, a, {
                     patternEval: ((k, v) => v.application === a)
@@ -9845,7 +9423,7 @@ Bitcoin.Util = {
                     promises.push(compactIDB.removeData("lastTx", floGlobals.appList[a]))
                     promises.push(compactIDB.removeData("appSubAdmins", a))
                 });
-                return Promises.all(promises);
+                return Promise.allSettled(promises);
             }
 
             unauthoriseApps(delApps).then(result => {