From 2285ab4577567a4e4f797cf501fb2ae159746eff Mon Sep 17 00:00:00 2001
From: sairajzero <sairaj0630@gmail.com>
Date: Sun, 18 Apr 2021 02:10:55 +0530
Subject: [PATCH] update stdop

---
 floBank.html | 2694 ++++++++++++++++++++++++++------------------------
 1 file changed, 1391 insertions(+), 1303 deletions(-)

diff --git a/floBank.html b/floBank.html
index ff8afbf..7b41db6 100644
--- a/floBank.html
+++ b/floBank.html
@@ -5,36 +5,36 @@
   <title>FLO Standard Operators</title>
 
 <script id="floGlobals">
-  /* Constants for FLO blockchain operations !!Make sure to add this at begining!! */
-  const floGlobals = {
+    /* Constants for FLO blockchain operations !!Make sure to add this at begining!! */
+    const floGlobals = {
 
-    //Required for all
-    blockchain: "FLO",
+        //Required for all
+        blockchain: "FLO",
 
-    //Required for blockchain API operators
-    apiURL: {
-      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/']
-    },
-    adminID: "FKAEdnPfjXLHSYwrXQu377ugN4tXU7VGdf",
-    sendAmt: 0.001,
-    fee: 0.0005,
+        //Required for blockchain API operators
+        apiURL: {
+            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/']
+        },
+        tokenURL: "https://ranchimallflo.duckdns.org/",
+        token: "rupee",
+        adminID: "FKAEdnPfjXLHSYwrXQu377ugN4tXU7VGdf",
+        sendAmt: 0.001,
+        fee: 0.0005,
 
-    //Required for Supernode operations
-    SNStorageID: "FEzk75EGMPEQMrCuPosGiwuK162hcEu49E",
-    supernodes: {}, //each supnernode must be stored as floID : {uri:<uri>,pubKey:<publicKey>}
+        //Required for Supernode operations
+        SNStorageID: "FNaN9McoBAEFUjkRmNQRYLmBF8SpS7Tgfk",
+        supernodes: {}, //each supnernode must be stored as floID : {uri:<uri>,pubKey:<publicKey>}
 
-    //for cloud apps
-    subAdmins: [],
-    application: "TEST_MODE_BANK",
-    vectorClock: {},
-    appObjects: {},
-    generalData: {},
-    generalVC: {},
-
-    //bank app
-    collaterals : []
-  }
+        //for cloud apps
+        subAdmins: [],
+        application: "TEST_MODE",
+        appObjects: {},
+        generalData: {},
+        lastVC: {}
+    }
 </script>
 
 </head>
@@ -43,7 +43,7 @@
     TEST_MODE
   (use console)
 
-<script id="init_lib">
+<script id="init_lib" version="1.0.1">
     //All util libraries required for Standard operations (DO NOT EDIT ANY)
 
       /* Reactor Event handling */
@@ -4934,12 +4934,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);
@@ -6741,27 +6741,22 @@ Bitcoin.Util = {
     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
+    findDiff(original, updatedObj) returns an object with the added, deleted and updated differences  
+    mergeRecursive(original, diff) returns a new object that will merge difference to old object
+    mergeDiff(original, allDiff) returns a new object from original object merged with all differences (allDiff is returned object of findDiff)
     */
 (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 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 {
@@ -6771,13 +6766,11 @@ Bitcoin.Util = {
                 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]
@@ -6785,31 +6778,21 @@ Bitcoin.Util = {
       }, {});
     };
     
-    
     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;
       }, {});
     };
@@ -6817,123 +6800,90 @@ Bitcoin.Util = {
     
     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) => ({
+    window.findDiff = (lhs, rhs) => ({
       added: addedDiff(lhs, rhs),
       deleted: deletedDiff(lhs, rhs),
       updated: updatedDiff(lhs, rhs),
@@ -6942,22 +6892,17 @@ Bitcoin.Util = {
     const mergeRecursive = (obj1, obj2) => {
         for (var p in obj2) {
             try {
-                if(obj2[p].constructor == Object) {
+                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) {
+                    if (obj2[p].length < 1) 
                         obj1[p] = obj2[p];
-                    }
-                    else {
+                    else 
                         obj1[p] = mergeRecursive(obj1[p], obj2[p]);
-                    }
-    
-                }else{
+                }else
                     obj1[p] = obj2[p];
-                }
             } catch (e) {
                 // Property in destination object not set; create it and set its value.
                 obj1[p] = obj2[p];
@@ -6966,19 +6911,6 @@ Bitcoin.Util = {
         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];
@@ -6986,40 +6918,34 @@ Bitcoin.Util = {
                 // 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 (!Object.keys(value).length) 
+                  //  delete obj[key];
             }
+            else if (value === null) 
+                delete obj[key];// null, remove it
         });
-    
-    if(obj.constructor.toString().indexOf("Array") != -1)  {obj = obj.filter(function (el) {
-      return el != null;
-    });}
-    
-    return obj; 
+        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) => {
+    /*obj is original object or array, diff is the output of findDiff */
+    window.mergeDiff = (obj, diff) => {
       if(Object.keys(diff.updated).length !== 0)
-        obj = mergeRecursive(obj,diff.updated)
+        obj = mergeRecursive(obj, diff.updated)
       if(Object.keys(diff.deleted).length !== 0){
-        obj = mergeRecursive(obj,diff.deleted)
+        obj = mergeRecursive(obj, diff.deleted)
         obj = cleanse(obj)
       }
       if(Object.keys(diff.added).length !== 0)
-        obj = mergeRecursive(obj,diff.added)
+        obj = mergeRecursive(obj, diff.added)
         return obj
     }
 })();
 </script>
 
-<script id="floCrypto">
+<script id="floCrypto" version="2.0.0">
     /* FLO Crypto Operators*/
     const floCrypto = {
 
@@ -7028,17 +6954,17 @@ Bitcoin.Util = {
 
             ecparams: EllipticCurve.getSECCurveByName("secp256k1"),
 
-            exponent1: function () {
+            exponent1: function() {
                 return this.p.add(BigInteger.ONE).divide(BigInteger("4"))
             },
 
-            calculateY: function (x) {
+            calculateY: function(x) {
                 let p = this.p;
                 let exp = this.exponent1();
                 // x is x value of public key in BigInteger format without 02 or 03 or 04 prefix
                 return x.modPow(BigInteger("3"), p).add(BigInteger("7")).mod(p).modPow(exp, p)
             },
-            getUncompressedPublicKey: function (compressedPublicKey) {
+            getUncompressedPublicKey: function(compressedPublicKey) {
                 const p = this.p;
                 // Fetch x from compressedPublicKey
                 let pubKeyBytes = Crypto.util.hexToBytes(compressedPublicKey);
@@ -7062,7 +6988,7 @@ Bitcoin.Util = {
                 };
             },
 
-            getSenderPublicKeyString: function () {
+            getSenderPublicKeyString: function() {
                 privateKey = ellipticCurveEncryption.senderRandom();
                 senderPublicKeyString = ellipticCurveEncryption.senderPublicString(privateKey);
                 return {
@@ -7071,7 +6997,7 @@ Bitcoin.Util = {
                 }
             },
 
-            deriveSharedKeySender: function (receiverCompressedPublicKey, senderPrivateKey) {
+            deriveSharedKeySender: function(receiverCompressedPublicKey, senderPrivateKey) {
                 try {
                     let receiverPublicKeyString = this.getUncompressedPublicKey(receiverCompressedPublicKey);
                     var senderDerivedKey = ellipticCurveEncryption.senderSharedKeyDerivation(
@@ -7082,17 +7008,17 @@ Bitcoin.Util = {
                 }
             },
 
-            deriveReceiverSharedKey: function (senderPublicKeyString, receiverPrivateKey) {
+            deriveReceiverSharedKey: function(senderPublicKeyString, receiverPrivateKey) {
                 return ellipticCurveEncryption.receiverSharedKeyDerivation(
                     senderPublicKeyString.XValuePublicString, senderPublicKeyString.YValuePublicString,
                     receiverPrivateKey);
             },
 
-            getReceiverPublicKeyString: function (privateKey) {
+            getReceiverPublicKeyString: function(privateKey) {
                 return ellipticCurveEncryption.receiverPublicString(privateKey);
             },
 
-            deriveSharedKeyReceiver: function (senderPublicKeyString, receiverPrivateKey) {
+            deriveSharedKeyReceiver: function(senderPublicKeyString, receiverPrivateKey) {
                 try {
                     return ellipticCurveEncryption.receiverSharedKeyDerivation(senderPublicKeyString
                         .XValuePublicString,
@@ -7103,7 +7029,7 @@ Bitcoin.Util = {
                 }
             },
 
-            wifToDecimal: function (pk_wif, isPubKeyCompressed = false) {
+            wifToDecimal: function(pk_wif, isPubKeyCompressed = false) {
                 let pk = Bitcoin.Base58.decode(pk_wif)
                 pk.shift()
                 pk.splice(-4, 4)
@@ -7120,14 +7046,14 @@ Bitcoin.Util = {
         },
 
         //generate a random Interger within range
-        randInt: function (min, max) {
+        randInt: function(min, max) {
             min = Math.ceil(min);
             max = Math.floor(max);
             return Math.floor(Math.random() * (max - min + 1)) + min;
         },
 
         //generate a random String within length (options : alphaNumeric chars only)
-        randString: function (length, alphaNumeric = false) {
+        randString: function(length, alphaNumeric = true) {
             var result = '';
             if (alphaNumeric)
                 var characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
@@ -7140,7 +7066,7 @@ Bitcoin.Util = {
         },
 
         //Encrypt Data using public-key
-        encryptData: function (data, receiverCompressedPublicKey) {
+        encryptData: function(data, receiverCompressedPublicKey) {
             var senderECKeyData = this.util.getSenderPublicKeyString();
             var senderDerivedKey = this.util.deriveSharedKeySender(receiverCompressedPublicKey, senderECKeyData
                 .privateKey);
@@ -7153,7 +7079,7 @@ Bitcoin.Util = {
         },
 
         //Decrypt Data using private-key
-        decryptData: function (data, myPrivateKey) {
+        decryptData: function(data, myPrivateKey) {
             var receiverECKeyData = {};
             if (typeof myPrivateKey !== "string") throw new Error("No private key found.");
 
@@ -7172,7 +7098,7 @@ Bitcoin.Util = {
         },
 
         //Sign data using private-key
-        signData: function (data, privateKeyHex) {
+        signData: function(data, privateKeyHex) {
             var key = new Bitcoin.ECKey(privateKeyHex);
             key.setCompressed(true);
 
@@ -7188,7 +7114,7 @@ Bitcoin.Util = {
         },
 
         //Verify signatue of the data using public-key
-        verifySign: function (data, signatureHex, publicKeyHex) {
+        verifySign: function(data, signatureHex, publicKeyHex) {
             var msgHash = Crypto.SHA256(data);
             var messageHashBigInteger = new BigInteger(msgHash);
 
@@ -7203,7 +7129,7 @@ Bitcoin.Util = {
         },
 
         //Generates a new flo ID and returns private-key, public-key and floID
-        generateNewID: function () {
+        generateNewID: function() {
             try {
                 var key = new Bitcoin.ECKey(false);
                 key.setCompressed(true);
@@ -7218,30 +7144,34 @@ Bitcoin.Util = {
         },
 
         //Returns public-key from private-key
-        getPubKeyHex: function (privateKeyHex) {
-            if(!privateKeyHex)
+        getPubKeyHex: function(privateKeyHex) {
+            if (!privateKeyHex)
                 return null;
             var key = new Bitcoin.ECKey(privateKeyHex);
-            if (key.priv == null) 
+            if (key.priv == null)
                 return null;
             key.setCompressed(true);
-            var pubkeyHex = key.getPubKeyHex();
-            return pubkeyHex;
+            return key.getPubKeyHex();
         },
 
-        //Returns flo-ID from public-key
-        getFloIDfromPubkeyHex: function (pubkeyHex) {
+        //Returns flo-ID from public-key or private-key
+        getFloID: function(keyHex) {
+            if (!keyHex)
+                return null;
             try {
-                var key = new Bitcoin.ECKey().setPub(pubkeyHex);
-                var floID = key.getBitcoinAddress();
-                return floID;
+                var key = new Bitcoin.ECKey(keyHex);
+                if (key.priv == null)
+                    key.setPub(keyHex);
+                return key.getBitcoinAddress();
             } catch (e) {
-                console.error(e);
+                return null;
             }
         },
 
         //Verify the private-key for the given public-key or flo-ID
-        verifyPrivKey: function (privateKeyHex, pubKey_floID, isfloID = true) {
+        verifyPrivKey: function(privateKeyHex, pubKey_floID, isfloID = true) {
+            if (!privateKeyHex || !pubKey_floID)
+                return false;
             try {
                 var key = new Bitcoin.ECKey(privateKeyHex);
                 if (key.priv == null)
@@ -7259,7 +7189,9 @@ Bitcoin.Util = {
         },
 
         //Check if the given Address is valid or not
-        validateAddr: function (inpAddr) {
+        validateAddr: function(inpAddr) {
+            if (!inpAddr)
+                return false;
             try {
                 var addr = new Bitcoin.Address(inpAddr);
                 return true;
@@ -7269,7 +7201,7 @@ Bitcoin.Util = {
         },
 
         //Split the str using shamir's Secret and Returns the shares 
-        createShamirsSecretShares: function (str, total_shares, threshold_limit) {
+        createShamirsSecretShares: function(str, total_shares, threshold_limit) {
             try {
                 if (str.length > 0) {
                     var strHex = shamirSecretShare.str2hex(str);
@@ -7283,12 +7215,12 @@ Bitcoin.Util = {
         },
 
         //Verifies the shares and str
-        verifyShamirsSecret: function (sharesArray, str) {
+        verifyShamirsSecret: function(sharesArray, str) {
             return (str && this.retrieveShamirSecret(sharesArray) === str)
         },
 
         //Returns the retrived secret by combining the shamirs shares
-        retrieveShamirSecret: function (sharesArray) {
+        retrieveShamirSecret: function(sharesArray) {
             try {
                 if (sharesArray.length > 0) {
                     var comb = shamirSecretShare.combine(sharesArray.slice(0, sharesArray.length));
@@ -7302,14 +7234,14 @@ Bitcoin.Util = {
         }
     }
 </script>
-<script id="floBlockchainAPI">
+<script id="floBlockchainAPI" version="2.0.1">
     /* FLO Blockchain Operator to send/receive data from blockchain using API calls*/
     const floBlockchainAPI = {
 
         util: {
             serverList: floGlobals.apiURL[floGlobals.blockchain].slice(0),
             curPos: floCrypto.randInt(0, floGlobals.apiURL[floGlobals.blockchain].length),
-            fetch_retry: function (apicall) {
+            fetch_retry: function(apicall) {
                 return new Promise((resolve, reject) => {
                     this.serverList.splice(this.curPos, 1);
                     this.curPos = floCrypto.randInt(0, this.serverList.length)
@@ -7318,7 +7250,7 @@ Bitcoin.Util = {
                         .catch(error => reject(error));
                 })
             },
-            fetch_api: function (apicall) {
+            fetch_api: function(apicall) {
                 return new Promise((resolve, reject) => {
                     if (this.serverList.length === 0)
                         reject("No floSight server working")
@@ -7342,7 +7274,7 @@ Bitcoin.Util = {
         },
 
         //Promised function to get data from API
-        promisedAPI: function (apicall) {
+        promisedAPI: function(apicall) {
             return new Promise((resolve, reject) => {
                 console.log(apicall)
                 this.util.fetch_api(apicall)
@@ -7352,7 +7284,7 @@ Bitcoin.Util = {
         },
 
         //Get balance for the given Address
-        getBalance: function (addr) {
+        getBalance: function(addr) {
             return new Promise((resolve, reject) => {
                 this.promisedAPI(`api/addr/${addr}/balance`)
                     .then(balance => resolve(parseFloat(balance)))
@@ -7361,7 +7293,7 @@ Bitcoin.Util = {
         },
 
         //Write Data into blockchain
-        writeData: function (senderAddr, data, privKey, receiverAddr = floGlobals.adminID) {
+        writeData: function(senderAddr, data, privKey, receiverAddr = floGlobals.adminID) {
             return new Promise((resolve, reject) => {
                 if (typeof data != "string")
                     data = JSON.stringify(data);
@@ -7372,7 +7304,7 @@ Bitcoin.Util = {
         },
 
         //Send Tx to blockchain 
-        sendTx: function (senderAddr, receiverAddr, sendAmt, privKey, floData = '') {
+        sendTx: function(senderAddr, receiverAddr, sendAmt, privKey, floData = '') {
             return new Promise((resolve, reject) => {
                 if (!floCrypto.validateAddr(senderAddr))
                     reject(`Invalid address : ${senderAddr}`);
@@ -7402,7 +7334,7 @@ Bitcoin.Util = {
                             var change = utxoAmt - sendAmt - fee;
                             if (change > 0)
                                 trx.addoutput(senderAddr, change);
-                            trx.addflodata(floData.replace(/\n/g,' '));
+                            trx.addflodata(floData.replace(/\n/g, ' '));
                             var signedTxHash = trx.sign(privKey, 1);
                             this.broadcastTx(signedTxHash)
                                 .then(txid => resolve(txid))
@@ -7414,7 +7346,7 @@ Bitcoin.Util = {
         },
 
         //merge all UTXOs of a given floID into a single UTXO
-        mergeUTXOs: function (floID, privKey, floData = '') {
+        mergeUTXOs: function(floID, privKey, floData = '') {
             return new Promise((resolve, reject) => {
                 if (!floCrypto.validateAddr(floID))
                     return reject(`Invalid floID`);
@@ -7433,7 +7365,7 @@ Bitcoin.Util = {
                         }
                     }
                     trx.addoutput(floID, utxoAmt - fee);
-                    trx.addflodata(floData.replace(/\n/g,' '));
+                    trx.addflodata(floData.replace(/\n/g, ' '));
                     var signedTxHash = trx.sign(privKey, 1);
                     this.broadcastTx(signedTxHash)
                         .then(txid => resolve(txid))
@@ -7449,11 +7381,11 @@ Bitcoin.Util = {
          * @param  {boolean} preserveRatio (optional) preserve ratio or equal contribution
          * @return {Promise}
          */
-        writeDataMultiple: function (senderPrivKeys, data, receivers = [floGlobals.adminID], preserveRatio = true){
+        writeDataMultiple: function(senderPrivKeys, data, receivers = [floGlobals.adminID], preserveRatio = true) {
             return new Promise((resolve, reject) => {
-                if (!Array.isArray(senderPrivKeys)) 
+                if (!Array.isArray(senderPrivKeys))
                     return reject("Invalid senderPrivKeys: SenderPrivKeys must be Array")
-                if(!preserveRatio){
+                if (!preserveRatio) {
                     let tmp = {};
                     let amount = (floGlobals.sendAmt * receivers.length) / senderPrivKeys.length;
                     senderPrivKeys.forEach(key => tmp[key] = amount);
@@ -7481,56 +7413,59 @@ Bitcoin.Util = {
          * @param  {string} floData FLO data of the txn
          * @return {Promise}
          */
-        sendTxMultiple: function (senderPrivKeys, receivers, floData = '') {
+        sendTxMultiple: function(senderPrivKeys, receivers, floData = '') {
             return new Promise((resolve, reject) => {
-                
-                let senders = {}, preserveRatio; 
+
+                let senders = {},
+                    preserveRatio;
                 //check for argument validations
-                try{
+                try {
                     let invalids = {
                         InvalidSenderPrivKeys: [],
                         InvalidSenderAmountFor: [],
                         InvalidReceiverIDs: [],
                         InvalidReceiveAmountFor: []
                     }
-                    let inputVal = 0, outputVal = 0;
+                    let inputVal = 0,
+                        outputVal = 0;
                     //Validate sender privatekeys (and send amount if passed)
                     //conversion when only privateKeys are passed (preserveRatio mode)
-                    if(Array.isArray(senderPrivKeys)){  
+                    if (Array.isArray(senderPrivKeys)) {
                         senderPrivKeys.forEach(key => {
-                            try{
-                                if(!key)
+                            try {
+                                if (!key)
                                     invalids.InvalidSenderPrivKeys.push(key);
-                                else{
-                                    let floID = floCrypto.getFloIDfromPubkeyHex(floCrypto.getPubKeyHex(key));
+                                else {
+                                    let floID = floCrypto.getFloID(key);
                                     senders[floID] = {
                                         wif: key
                                     }
                                 }
-                            }catch(error){
+                            } catch (error) {
                                 invalids.InvalidSenderPrivKeys.push(key)
                             }
                         })
                         preserveRatio = true;
                     }
                     //conversion when privatekeys are passed with send amount
-                    else{
-                        for(let key in senderPrivKeys){
-                            try{
-                                if(!key)
+                    else {
+                        for (let key in senderPrivKeys) {
+                            try {
+                                if (!key)
                                     invalids.InvalidSenderPrivKeys.push(key);
-                                else{
-                                    if(typeof senderPrivKeys[key] !== 'number' || senderPrivKeys[key] <= 0)
+                                else {
+                                    if (typeof senderPrivKeys[key] !== 'number' || senderPrivKeys[
+                                            key] <= 0)
                                         invalids.InvalidSenderAmountFor.push(key)
                                     else
                                         inputVal += senderPrivKeys[key];
-                                    let floID = floCrypto.getFloIDfromPubkeyHex(floCrypto.getPubKeyHex(key));
+                                    let floID = floCrypto.getFloID(key);
                                     senders[floID] = {
                                         wif: key,
                                         coins: senderPrivKeys[key]
                                     }
                                 }
-                            }catch(error){
+                            } catch (error) {
                                 invalids.InvalidSenderPrivKeys.push(key)
                             }
                         }
@@ -7552,9 +7487,10 @@ Bitcoin.Util = {
                     if (Object.keys(invalids).length)
                         return reject(invalids);
                     //Reject if given inputVal and outputVal are not equal
-                    if(!preserveRatio && inputVal != outputVal)
-                        return reject(`Input Amount (${inputVal}) not equal to Output Amount (${outputVal})`)
-                }catch(error){
+                    if (!preserveRatio && inputVal != outputVal)
+                        return reject(
+                            `Input Amount (${inputVal}) not equal to Output Amount (${outputVal})`)
+                } catch (error) {
                     return reject(error)
                 }
                 //Get balance of senders
@@ -7566,18 +7502,22 @@ Bitcoin.Util = {
                         totalFee = floGlobals.fee,
                         balance = {};
                     //Divide fee among sender if not for preserveRatio
-                    if(!preserveRatio) 
+                    if (!preserveRatio)
                         var dividedFee = totalFee / Object.keys(senders).length;
                     //Check if balance of each sender is sufficient enough
                     let insufficient = [];
                     for (let floID in senders) {
                         balance[floID] = parseFloat(results.shift());
-                        if (isNaN(balance[floID]) || (preserveRatio && balance[floID] <= totalFee) || (!preserveRatio && balance[floID] < senders[floID].coins + dividedFee))
+                        if (isNaN(balance[floID]) || (preserveRatio && balance[floID] <=
+                                totalFee) || (!preserveRatio && balance[floID] < senders[floID]
+                                .coins + dividedFee))
                             insufficient.push(floID)
                         totalBalance += balance[floID];
                     }
                     if (insufficient.length)
-                        return reject({InsufficientBalance: insufficient})
+                        return reject({
+                            InsufficientBalance: insufficient
+                        })
                     //Calculate totalSentAmount and check if totalBalance is sufficient
                     let totalSendAmt = totalFee;
                     for (floID in receivers)
@@ -7594,10 +7534,10 @@ Bitcoin.Util = {
                         for (floID in senders) {
                             let utxos = results.shift();
                             let sendAmt;
-                            if(preserveRatio){
+                            if (preserveRatio) {
                                 let ratio = (balance[floID] / totalBalance);
                                 sendAmt = totalSendAmt * ratio;
-                            } else 
+                            } else
                                 sendAmt = senders[floID].coins + dividedFee;
                             let wif = senders[floID].wif;
                             let utxoAmt = 0.0;
@@ -7618,7 +7558,7 @@ Bitcoin.Util = {
                         }
                         for (floID in receivers)
                             trx.addoutput(floID, receivers[floID]);
-                        trx.addflodata(floData.replace(/\n/g,' '));
+                        trx.addflodata(floData.replace(/\n/g, ' '));
                         for (let i = 0; i < wifSeq.length; i++)
                             trx.signinput(i, wifSeq[i], 1);
                         var signedTxHash = trx.serialize();
@@ -7631,7 +7571,7 @@ Bitcoin.Util = {
         },
 
         //Broadcast signed Tx in blockchain using API
-        broadcastTx: function (signedTxHash) {
+        broadcastTx: function(signedTxHash) {
             return new Promise((resolve, reject) => {
                 var request = new XMLHttpRequest();
                 var url = this.util.serverList[this.util.curPos] + 'api/tx/send';
@@ -7643,7 +7583,7 @@ Bitcoin.Util = {
                     request.open('POST', url, true);
                     //Send the proper header information along with the request
                     request.setRequestHeader('Content-type', 'application/json');
-                    request.onload = function () {
+                    request.onload = function() {
                         if (request.readyState == 4 && request.status == 200) {
                             console.log(request.response);
                             resolve(JSON.parse(request.response).txid.result);
@@ -7655,8 +7595,16 @@ Bitcoin.Util = {
             })
         },
 
+        getTx: function(txid) {
+            return new Promise((resolve, reject) => {
+                this.promisedAPI(`api/tx/${txid}`)
+                    .then(response => resolve(response))
+                    .catch(error => reject(error))
+            })
+        },
+
         //Read Txs of Address between from and to
-        readTxs: function (addr, from, to) {
+        readTxs: function(addr, from, to) {
             return new Promise((resolve, reject) => {
                 this.promisedAPI(`api/addrs/${addr}/txs?from=${from}&to=${to}`)
                     .then(response => resolve(response))
@@ -7665,7 +7613,7 @@ Bitcoin.Util = {
         },
 
         //Read All Txs of Address (newest first)
-        readAllTxs: function (addr) {
+        readAllTxs: function(addr) {
             return new Promise((resolve, reject) => {
                 this.promisedAPI(`api/addrs/${addr}/txs?from=0&to=1`).then(response => {
                     this.promisedAPI(`api/addrs/${addr}/txs?from=0&to=${response.totalItems}0`)
@@ -7684,8 +7632,8 @@ Bitcoin.Util = {
         contains    : filters data that contains a string
         filter      : custom filter funtion for floData (eg . filter: d => {return d[0] == '$'})
         */
-        readData: function (addr, options = {}) {
-            options.limit = options.limit | 1000
+        readData: function(addr, options = {}) {
+            options.limit = options.limit | 0
             options.ignoreOld = options.ignoreOld | 0
             return new Promise((resolve, reject) => {
                 this.promisedAPI(`api/addrs/${addr}/txs?from=0&to=1`).then(response => {
@@ -7700,13 +7648,17 @@ Bitcoin.Util = {
                                 if (options.sentOnly && response.items[i].vin[0].addr !==
                                     addr)
                                     continue;
-                                if (options.pattern && !response.items[i].floData
-                                    .startsWith(options.pattern, 0) && !response.items[i]
-                                    .floData.startsWith(options.pattern, 2))
-                                    continue;
-                                if (options.contains && !response.items[i].floData.includes(
-                                        options.contains))
-                                    continue;
+                                if (options.pattern) {
+                                    try {
+                                        let jsonContent = JSON.parse(response.items[i]
+                                            .floData)
+                                        if (!Object.keys(jsonContent).includes(options
+                                                .pattern))
+                                            continue;
+                                    } catch (error) {
+                                        continue;
+                                    }
+                                }
                                 if (options.filter && !options.filter(response.items[i]
                                         .floData))
                                     continue;
@@ -7726,644 +7678,7 @@ Bitcoin.Util = {
         }
     }
 </script>
-<script id="floSupernode">
-    /* flo Supernode Operators to send/receive data from supernodes using websocket */
-    const floSupernode = {
-
-        //kBucket object 
-        kBucket: {
-            supernodeKBucket: null,
-            decodeBase58Address: function (address) {
-                let k = bitjs.Base58.decode(address)
-                k.shift()
-                k.splice(-4, 4)
-                return Crypto.util.bytesToHex(k)
-            },
-            floIdToKbucketId: function (address) {
-                const decodedId = this.decodeBase58Address(address);
-                const nodeIdBigInt = new BigInteger(decodedId, 16);
-                const nodeIdBytes = nodeIdBigInt.toByteArrayUnsigned();
-                const nodeIdNewInt8Array = new Uint8Array(nodeIdBytes);
-                return nodeIdNewInt8Array;
-            },
-            launch: function (superNodeList = Object.keys(floGlobals.supernodes), master_floID = floGlobals
-            .adminID) {
-                return new Promise((resolve, reject) => {
-                    try {
-                        const SuKBucketId = this.floIdToKbucketId(master_floID);
-                        const SukbOptions = {
-                            localNodeId: SuKBucketId
-                        }
-                        this.supernodeKBucket = new BuildKBucket(SukbOptions);
-                        for (var i = 0; i < superNodeList.length; i++) {
-                            this.addNewNode(superNodeList[i])
-                        }
-                        resolve('SuperNode KBucket formed');
-                    } catch (error) {
-                        reject(error);
-                    }
-                });
-            },
-            addContact: function (id, floID, KB = this.supernodeKBucket) {
-                const contact = {
-                    id: id,
-                    floID: floID
-                };
-                KB.add(contact)
-            },
-            addNewNode: function (address, KB = this.supernodeKBucket) {
-                let decodedId = address;
-                try {
-                    decodedId = this.floIdToKbucketId(address);
-                } catch (e) {
-                    decodedId = address;
-                }
-                this.addContact(decodedId, address, KB);
-            },
-            isNodePresent: function (flo_id, KB = this.supernodeKBucket) {
-                let kArray = KB.toArray();
-                let kArrayFloIds = kArray.map(k => k.floID);
-                if (kArrayFloIds.includes(flo_id))
-                    return true;
-                else
-                    return false;
-            },
-
-            getInnerNodes: function (flo_addr1, flo_addr2, KB = this.supernodeKBucket) {
-                return new Promise((resolve, reject) => {
-                    let kArrayFloIds = KB.toArray().map(k => k.floID);
-                    var innerNodes = []
-                    if (kArrayFloIds.includes(flo_addr1) && kArrayFloIds.includes(flo_addr2)) {
-                        for (var i = kArrayFloIds.indexOf(flo_addr1); i != flo_addr2; i++) {
-                            if (i >= kArrayFloIds.length)
-                                i = -1
-                            else
-                                innerNodes.push(kArrayFloIds[i])
-                        }
-                        resolve(innerNodes)
-                    } else
-                        reject('Given nodes are not in KBucket')
-                });
-            },
-
-            getOuterNodes: function (flo_addr1, flo_addr2, KB = this.supernodeKBucket) {
-                return new Promise((resolve, reject) => {
-                    let kArrayFloIds = KB.toArray().map(k => k.floID);
-                    var outterNodes = []
-                    if (kArrayFloIds.includes(flo_addr1) && kArrayFloIds.includes(flo_addr2)) {
-                        for (var i = kArrayFloIds.indexOf(flo_addr2); i != flo_addr1; i++) {
-                            if (i >= kArrayFloIds.length)
-                                i = -1
-                            else
-                                outterNodes.push(kArrayFloIds[i])
-                        }
-                        resolve(outterNodes)
-                    } else
-                        reject('Given nodes are not in KBucket')
-                });
-            },
-
-            getPrevSupernode: function (flo_addr, n = 1, KB = this.supernodeKBucket) {
-                return new Promise((resolve, reject) => {
-                    try {
-                        let kArrayFloIds = KB.toArray().map(k => k.floID);
-                        let pos = kArrayFloIds.indexOf(flo_addr)
-                        var prevSupernode = []
-                        for (var i = 1; i <= n; i++) {
-                            if (pos - i < 0)
-                                var prev = pos - i + kArrayFloIds.length
-                            else
-                                var prev = pos - i
-                            prevSupernode.push(kArrayFloIds[prev])
-                        }
-                        resolve(prevSupernode);
-                    } catch (error) {
-                        reject(error);
-                    }
-                });
-            },
-
-            getNextSupernode: function (flo_addr, n = 1, KB = this.supernodeKBucket) {
-                return new Promise((resolve, reject) => {
-                    try {
-                        let kArrayFloIds = KB.toArray().map(k => k.floID);
-                        let pos = kArrayFloIds.indexOf(flo_addr)
-                        var nextSupernode = []
-                        for (var i = 1; i <= n; i++) {
-                            if (pos + i >= kArrayFloIds.length)
-                                var next = pos + i - kArrayFloIds.length
-                            else
-                                var next = pos + i
-                            nextSupernode.push(kArrayFloIds[next])
-                        }
-                        resolve(nextSupernode);
-                    } catch (error) {
-                        reject(error);
-                    }
-                });
-            },
-
-            determineClosestSupernode: function (flo_addr, n = 1, KB = this.supernodeKBucket) {
-                return new Promise((resolve, reject) => {
-                    try {
-                        let isFloIdUint8 = flo_addr instanceof Uint8Array;
-                        if (!isFloIdUint8)
-                            flo_addr = this.floIdToKbucketId(flo_addr);
-                        var closestSupernode = KB.closest(flo_addr, n);
-                        closestSupernode = closestSupernode.map(k => k.floID);
-                        resolve(closestSupernode);
-                    } catch (error) {
-                        reject(error);
-                    }
-                });
-            }
-        },
-
-        sendDataToSN(data, snfloID) {
-            return new Promise((resolve, reject) => {
-                var websocket = new WebSocket("wss://" + floGlobals.supernodes[snfloID].uri + "/ws");
-                websocket.onmessage = (evt => {
-                    if (evt.data == '$+') {
-                        websocket.send(data);
-                        resolve(`Data sent to supernode : ${snfloID}`);
-                    } else if (evt.data == '$-') {
-                        this.kBucket.getNextSupernode(snfloID).then(nextNode => {
-                            this.sendDataToSN(data, nextNode[0])
-                                .then(result => resolve(result))
-                                .catch(error => reject(error))
-                        }).catch(error => reject(error))
-                    } else {
-                        console.log(evt.data)
-                        reject(evt.data)
-                    }
-                    websocket.close();
-                })
-                websocket.onerror = (evt) => {
-                    this.kBucket.getNextSupernode(snfloID).then(nextNode => {
-                        this.sendDataToSN(data, nextNode[0])
-                            .then(result => resolve(result))
-                            .catch(error => reject(error))
-                    }).catch(error => reject(error))
-                };
-            })
-        },
-
-        //Sends data to the supernode
-        sendData: function (data, floID) {
-            return new Promise((resolve, reject) => {
-                this.kBucket.determineClosestSupernode(floID).then(closestNode => {
-                    this.sendDataToSN(data, closestNode[0])
-                        .then(result => resolve(result))
-                        .catch(error => reject(error))
-                }).catch(error => {
-                    reject(error);
-                });
-            });
-        },
-
-        requestDataFromSN(request, snfloID) {
-            return new Promise((resolve, reject) => {
-                var websocket = new WebSocket("wss://" + floGlobals.supernodes[snfloID].uri + "/ws");
-                websocket.onmessage = (evt => {
-                    if (evt.data == '$+') {
-                        websocket.send(`?${request}`);
-                    } else if (evt.data == '$-') {
-                        this.kBucket.getNextSupernode(snfloID).then(nextNode => {
-                            this.requestDataFromSN(request, nextNode[0])
-                                .then(result => resolve(result))
-                                .catch(error => reject(error))
-                        }).catch(error => reject(error))
-                        websocket.close()
-                    } else {
-                        resolve(evt.data);
-                        websocket.close();
-                    }
-                })
-                websocket.onerror = (evt) => {
-                    this.kBucket.getNextSupernode(snfloID).then(nextNode => {
-                        this.requestDataFromSN(request, nextNode[0])
-                            .then(result => resolve(result))
-                            .catch(error => reject(error))
-                    }).catch(error => reject(error))
-                };
-            })
-        },
-
-        //Request data from supernode
-        requestData: function (request, floID) {
-            return new Promise((resolve, reject) => {
-                this.kBucket.determineClosestSupernode(floID).then(closestNode => {
-                    this.requestDataFromSN(request, closestNode[0])
-                        .then(result => resolve(result))
-                        .catch(error => reject(error))
-                }).catch(error => {
-                    reject(error);
-                });
-            });
-        }
-    }
-
-    /**Kademlia DHT K-bucket implementation as a binary tree.
-     * Implementation of a Kademlia DHT k-bucket used for storing
-     * contact (peer node) information.
-     *
-     * @extends EventEmitter
-     */
-    function BuildKBucket(options = {}) {
-        /**
-         * `options`:
-         *   `distance`: Function
-         *     `function (firstId, secondId) { return distance }` An optional
-         *     `distance` function that gets two `id` Uint8Arrays
-         *     and return distance (as number) between them.
-         *   `arbiter`: Function (Default: vectorClock arbiter)
-         *     `function (incumbent, candidate) { return contact; }` An optional
-         *     `arbiter` function that givent two `contact` objects with the same `id`
-         *     returns the desired object to be used for updating the k-bucket. For
-         *     more details, see [arbiter function](#arbiter-function).
-         *   `localNodeId`: Uint8Array An optional Uint8Array representing the local node id.
-         *     If not provided, a local node id will be created via `randomBytes(20)`.
-         *     `metadata`: Object (Default: {}) Optional satellite data to include
-         *     with the k-bucket. `metadata` property is guaranteed not be altered by,
-         *     it is provided as an explicit container for users of k-bucket to store
-         *     implementation-specific data.
-         *   `numberOfNodesPerKBucket`: Integer (Default: 20) The number of nodes
-         *     that a k-bucket can contain before being full or split.
-         *     `numberOfNodesToPing`: Integer (Default: 3) The number of nodes to
-         *     ping when a bucket that should not be split becomes full. KBucket will
-         *     emit a `ping` event that contains `numberOfNodesToPing` nodes that have
-         *     not been contacted the longest.
-         *
-         * @param {Object=} options optional
-         */
-
-        this.localNodeId = options.localNodeId || window.crypto.getRandomValues(new Uint8Array(20))
-        this.numberOfNodesPerKBucket = options.numberOfNodesPerKBucket || 20
-        this.numberOfNodesToPing = options.numberOfNodesToPing || 3
-        this.distance = options.distance || this.distance
-        // use an arbiter from options or vectorClock arbiter by default
-        this.arbiter = options.arbiter || this.arbiter
-        this.metadata = Object.assign({}, options.metadata)
-
-        this.createNode = function () {
-            return {
-                contacts: [],
-                dontSplit: false,
-                left: null,
-                right: null
-            }
-        }
-
-        this.ensureInt8 = function (name, val) {
-            if (!(val instanceof Uint8Array)) {
-                throw new TypeError(name + ' is not a Uint8Array')
-            }
-        }
-
-        /**
-         * @param  {Uint8Array} array1
-         * @param  {Uint8Array} array2
-         * @return {Boolean}
-         */
-        this.arrayEquals = function (array1, array2) {
-            if (array1 === array2) {
-                return true
-            }
-            if (array1.length !== array2.length) {
-                return false
-            }
-            for (let i = 0, length = array1.length; i < length; ++i) {
-                if (array1[i] !== array2[i]) {
-                    return false
-                }
-            }
-            return true
-        }
-
-        this.ensureInt8('option.localNodeId as parameter 1', this.localNodeId)
-        this.root = this.createNode()
-
-        /**
-         * Default arbiter function for contacts with the same id. Uses
-         * contact.vectorClock to select which contact to update the k-bucket with.
-         * Contact with larger vectorClock field will be selected. If vectorClock is
-         * the same, candidat will be selected.
-         *
-         * @param  {Object} incumbent Contact currently stored in the k-bucket.
-         * @param  {Object} candidate Contact being added to the k-bucket.
-         * @return {Object}           Contact to updated the k-bucket with.
-         */
-        this.arbiter = function (incumbent, candidate) {
-            return incumbent.vectorClock > candidate.vectorClock ? incumbent : candidate
-        }
-
-        /**
-         * Default distance function. Finds the XOR
-         * distance between firstId and secondId.
-         *
-         * @param  {Uint8Array} firstId  Uint8Array containing first id.
-         * @param  {Uint8Array} secondId Uint8Array containing second id.
-         * @return {Number}              Integer The XOR distance between firstId
-         *                               and secondId.
-         */
-        this.distance = function (firstId, secondId) {
-            let distance = 0
-            let i = 0
-            const min = Math.min(firstId.length, secondId.length)
-            const max = Math.max(firstId.length, secondId.length)
-            for (; i < min; ++i) {
-                distance = distance * 256 + (firstId[i] ^ secondId[i])
-            }
-            for (; i < max; ++i) distance = distance * 256 + 255
-            return distance
-        }
-
-        /**
-         * Adds a contact to the k-bucket.
-         *
-         * @param {Object} contact the contact object to add
-         */
-        this.add = function (contact) {
-            this.ensureInt8('contact.id', (contact || {}).id)
-
-            let bitIndex = 0
-            let node = this.root
-
-            while (node.contacts === null) {
-                // this is not a leaf node but an inner node with 'low' and 'high'
-                // branches; we will check the appropriate bit of the identifier and
-                // delegate to the appropriate node for further processing
-                node = this._determineNode(node, contact.id, bitIndex++)
-            }
-
-            // check if the contact already exists
-            const index = this._indexOf(node, contact.id)
-            if (index >= 0) {
-                this._update(node, index, contact)
-                return this
-            }
-
-            if (node.contacts.length < this.numberOfNodesPerKBucket) {
-                node.contacts.push(contact)
-                return this
-            }
-
-            // the bucket is full
-            if (node.dontSplit) {
-                // we are not allowed to split the bucket
-                // we need to ping the first this.numberOfNodesToPing
-                // in order to determine if they are alive
-                // only if one of the pinged nodes does not respond, can the new contact
-                // be added (this prevents DoS flodding with new invalid contacts)
-                return this
-            }
-
-            this._split(node, bitIndex)
-            return this.add(contact)
-        }
-
-        /**
-         * Get the n closest contacts to the provided node id. "Closest" here means:
-         * closest according to the XOR metric of the contact node id.
-         *
-         * @param  {Uint8Array} id  Contact node id
-         * @param  {Number=} n      Integer (Default: Infinity) The maximum number of
-         *                          closest contacts to return
-         * @return {Array}          Array Maximum of n closest contacts to the node id
-         */
-        this.closest = function (id, n = Infinity) {
-            this.ensureInt8('id', id)
-
-            if ((!Number.isInteger(n) && n !== Infinity) || n <= 0) {
-                throw new TypeError('n is not positive number')
-            }
-
-            let contacts = []
-
-            for (let nodes = [this.root], bitIndex = 0; nodes.length > 0 && contacts.length < n;) {
-                const node = nodes.pop()
-                if (node.contacts === null) {
-                    const detNode = this._determineNode(node, id, bitIndex++)
-                    nodes.push(node.left === detNode ? node.right : node.left)
-                    nodes.push(detNode)
-                } else {
-                    contacts = contacts.concat(node.contacts)
-                }
-            }
-
-            return contacts
-                .map(a => [this.distance(a.id, id), a])
-                .sort((a, b) => a[0] - b[0])
-                .slice(0, n)
-                .map(a => a[1])
-        }
-
-        /**
-         * Counts the total number of contacts in the tree.
-         *
-         * @return {Number} The number of contacts held in the tree
-         */
-        this.count = function () {
-            // return this.toArray().length
-            let count = 0
-            for (const nodes = [this.root]; nodes.length > 0;) {
-                const node = nodes.pop()
-                if (node.contacts === null) nodes.push(node.right, node.left)
-                else count += node.contacts.length
-            }
-            return count
-        }
-
-        /**
-         * Determines whether the id at the bitIndex is 0 or 1.
-         * Return left leaf if `id` at `bitIndex` is 0, right leaf otherwise
-         *
-         * @param  {Object} node     internal object that has 2 leafs: left and right
-         * @param  {Uint8Array} id   Id to compare localNodeId with.
-         * @param  {Number} bitIndex Integer (Default: 0) The bit index to which bit
-         *                           to check in the id Uint8Array.
-         * @return {Object}          left leaf if id at bitIndex is 0, right leaf otherwise.
-         */
-        this._determineNode = function (node, id, bitIndex) {
-            // *NOTE* remember that id is a Uint8Array and has granularity of
-            // bytes (8 bits), whereas the bitIndex is the bit index (not byte)
-
-            // id's that are too short are put in low bucket (1 byte = 8 bits)
-            // (bitIndex >> 3) finds how many bytes the bitIndex describes
-            // bitIndex % 8 checks if we have extra bits beyond byte multiples
-            // if number of bytes is <= no. of bytes described by bitIndex and there
-            // are extra bits to consider, this means id has less bits than what
-            // bitIndex describes, id therefore is too short, and will be put in low
-            // bucket
-            const bytesDescribedByBitIndex = bitIndex >> 3
-            const bitIndexWithinByte = bitIndex % 8
-            if ((id.length <= bytesDescribedByBitIndex) && (bitIndexWithinByte !== 0)) {
-                return node.left
-            }
-
-            const byteUnderConsideration = id[bytesDescribedByBitIndex]
-
-            // byteUnderConsideration is an integer from 0 to 255 represented by 8 bits
-            // where 255 is 11111111 and 0 is 00000000
-            // in order to find out whether the bit at bitIndexWithinByte is set
-            // we construct (1 << (7 - bitIndexWithinByte)) which will consist
-            // of all bits being 0, with only one bit set to 1
-            // for example, if bitIndexWithinByte is 3, we will construct 00010000 by
-            // (1 << (7 - 3)) -> (1 << 4) -> 16
-            if (byteUnderConsideration & (1 << (7 - bitIndexWithinByte))) {
-                return node.right
-            }
-
-            return node.left
-        }
-
-        /**
-         * Get a contact by its exact ID.
-         * If this is a leaf, loop through the bucket contents and return the correct
-         * contact if we have it or null if not. If this is an inner node, determine
-         * which branch of the tree to traverse and repeat.
-         *
-         * @param  {Uint8Array} id The ID of the contact to fetch.
-         * @return {Object|Null}   The contact if available, otherwise null
-         */
-        this.get = function (id) {
-            this.ensureInt8('id', id)
-
-            let bitIndex = 0
-
-            let node = this.root
-            while (node.contacts === null) {
-                node = this._determineNode(node, id, bitIndex++)
-            }
-
-            // index of uses contact id for matching
-            const index = this._indexOf(node, id)
-            return index >= 0 ? node.contacts[index] : null
-        }
-
-        /**
-         * Returns the index of the contact with provided
-         * id if it exists, returns -1 otherwise.
-         *
-         * @param  {Object} node    internal object that has 2 leafs: left and right
-         * @param  {Uint8Array} id  Contact node id.
-         * @return {Number}         Integer Index of contact with provided id if it
-         *                          exists, -1 otherwise.
-         */
-        this._indexOf = function (node, id) {
-            for (let i = 0; i < node.contacts.length; ++i) {
-                if (this.arrayEquals(node.contacts[i].id, id)) return i
-            }
-
-            return -1
-        }
-
-        /**
-         * Removes contact with the provided id.
-         *
-         * @param  {Uint8Array} id The ID of the contact to remove.
-         * @return {Object}        The k-bucket itself.
-         */
-        this.remove = function (id) {
-            this.ensureInt8('the id as parameter 1', id)
-
-            let bitIndex = 0
-            let node = this.root
-
-            while (node.contacts === null) {
-                node = this._determineNode(node, id, bitIndex++)
-            }
-
-            const index = this._indexOf(node, id)
-            if (index >= 0) {
-                const contact = node.contacts.splice(index, 1)[0]
-            }
-
-            return this
-        }
-
-        /**
-         * Splits the node, redistributes contacts to the new nodes, and marks the
-         * node that was split as an inner node of the binary tree of nodes by
-         * setting this.root.contacts = null
-         *
-         * @param  {Object} node     node for splitting
-         * @param  {Number} bitIndex the bitIndex to which byte to check in the
-         *                           Uint8Array for navigating the binary tree
-         */
-        this._split = function (node, bitIndex) {
-            node.left = this.createNode()
-            node.right = this.createNode()
-
-            // redistribute existing contacts amongst the two newly created nodes
-            for (const contact of node.contacts) {
-                this._determineNode(node, contact.id, bitIndex).contacts.push(contact)
-            }
-
-            node.contacts = null // mark as inner tree node
-
-            // don't split the "far away" node
-            // we check where the local node would end up and mark the other one as
-            // "dontSplit" (i.e. "far away")
-            const detNode = this._determineNode(node, this.localNodeId, bitIndex)
-            const otherNode = node.left === detNode ? node.right : node.left
-            otherNode.dontSplit = true
-        }
-
-        /**
-         * Returns all the contacts contained in the tree as an array.
-         * If this is a leaf, return a copy of the bucket. `slice` is used so that we
-         * don't accidentally leak an internal reference out that might be
-         * accidentally misused. If this is not a leaf, return the union of the low
-         * and high branches (themselves also as arrays).
-         *
-         * @return {Array} All of the contacts in the tree, as an array
-         */
-        this.toArray = function () {
-            let result = []
-            for (const nodes = [this.root]; nodes.length > 0;) {
-                const node = nodes.pop()
-                if (node.contacts === null) nodes.push(node.right, node.left)
-                else result = result.concat(node.contacts)
-            }
-            return result
-        }
-
-        /**
-         * Updates the contact selected by the arbiter.
-         * If the selection is our old contact and the candidate is some new contact
-         * then the new contact is abandoned (not added).
-         * If the selection is our old contact and the candidate is our old contact
-         * then we are refreshing the contact and it is marked as most recently
-         * contacted (by being moved to the right/end of the bucket array).
-         * If the selection is our new contact, the old contact is removed and the new
-         * contact is marked as most recently contacted.
-         *
-         * @param  {Object} node    internal object that has 2 leafs: left and right
-         * @param  {Number} index   the index in the bucket where contact exists
-         *                          (index has already been computed in a previous
-         *                          calculation)
-         * @param  {Object} contact The contact object to update.
-         */
-        this._update = function (node, index, contact) {
-            // sanity check
-            if (!this.arrayEquals(node.contacts[index].id, contact.id)) {
-                throw new Error('wrong index for _update')
-            }
-
-            const incumbent = node.contacts[index]
-            const selection = this.arbiter(incumbent, contact)
-            // if the selection is our old contact and the candidate is some new
-            // contact, then there is nothing to do
-            if (selection === incumbent && incumbent !== contact) return
-
-            node.contacts.splice(index, 1) // remove old contact
-            node.contacts.push(selection) // add more recent contact version
-
-        }
-    }
-</script>
-<script id="compactIDB">
+<script id="compactIDB" version="2.0.1">
     /* Compact IndexedDB operations */
 
     window.indexedDB = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
@@ -8375,61 +7690,88 @@ Bitcoin.Util = {
 
     const compactIDB = {
 
-        setDefaultDB: function (dbName) {
+        setDefaultDB: function(dbName) {
             this.defaultDB = dbName;
         },
 
-        initDB: function (dbName, objectStores = {}, version = null, removeStores = []) {
+        upgradeDB: function(dbName, createList = null, deleteList = null) {
             return new Promise((resolve, reject) => {
-                this.defaultDB = this.defaultDB || dbName;
-                var idb = version ? indexedDB.open(dbName, version) : indexedDB.open(dbName);
-                idb.onerror = (event) => {
-                    reject("Error in opening IndexedDB!");
-                };
-                idb.onupgradeneeded = (event) => {
-                    var db = event.target.result;
-                    for (let obs in objectStores) {
-                        var objectStore = db.createObjectStore(obs, objectStores[obs].options ||
-                        {});
-                        if (objectStores[obs].indexes && typeof objectStores[obs].indexes ===
-                            'object')
-                            for (let i in objectStores[obs].indexes)
-                                objectStore.createIndex(i, i, objectStores[obs].indexes[i] || {});
+                this.getDBversion(dbName).then(version => {
+                    var idb = indexedDB.open(dbName, version + 1);
+                    idb.onerror = (event) => reject("Error in opening IndexedDB");
+                    idb.onupgradeneeded = (event) => {
+                        let db = event.target.result;
+                        if (createList instanceof Object) {
+                            if (Array.isArray(createList)) {
+                                let tmp = {}
+                                createList.forEach(o => tmp[o] = {})
+                                createList = tmp
+                            }
+                            for (let o in createList) {
+                                let obs = db.createObjectStore(o, createList[o].options || {});
+                                if (createList[o].indexes instanceof Object)
+                                    for (let i in createList[o].indexes)
+                                        obs.createIndex(i, i, createList[o].indexes || {});
+                            }
+                        }
+                        if (Array.isArray(deleteList))
+                            deleteList.forEach(o => db.deleteObjectStore(o));
+                        resolve('Database upgraded')
                     }
-                    if (version)
-                        removeStores.forEach(obs => db.deleteObjectStore(obs));
-                }
+                    idb.onsuccess = (event) => event.target.result.close();
+                }).catch(error => reject(error))
+            })
+        },
+
+        initDB: function(dbName, objectStores = {}) {
+            return new Promise((resolve, reject) => {
+                if (!(objectStores instanceof Object))
+                    return reject('ObjectStores must be an object or array')
+                this.defaultDB = this.defaultDB || dbName;
+                var idb = indexedDB.open(dbName);
+                idb.onerror = (event) => reject("Error in opening IndexedDB");
                 idb.onsuccess = (event) => {
                     var db = event.target.result;
-                    if (JSON.stringify(Object.values(db.objectStoreNames).sort()) === JSON
-                        .stringify(Object.keys(objectStores).sort()))
+                    let cList = Object.values(db.objectStoreNames);
+                    var obs = {},
+                        a_obs = {},
+                        d_obs = [];
+                    if (!Array.isArray(objectStores))
+                        var obs = objectStores
+                    else
+                        objectStores.forEach(o => obs[o] = {})
+                    let nList = Object.keys(obs)
+                    for (let o of nList)
+                        if (!cList.includes(o))
+                            a_obs[o] = obs[o]
+                    for (let o of cList)
+                        if (!nList.includes(o))
+                            d_obs.push(o)
+                    if (!Object.keys(a_obs).length && !d_obs.length)
                         resolve("Initiated IndexedDB");
-                    else {
-                        let removeObs = [];
-                        Object.values(db.objectStoreNames).forEach(obs => {
-                            if (obs in objectStores)
-                                delete objectStores[obs]
-                            else
-                                removeObs.push(obs)
-                        })
-                        this.initDB(dbName, objectStores, db.version + 1, removeObs)
-                            .then(result => resolve(result))
-                            .catch(error => reject(error))
-                    }
+                    else
+                        this.upgradeDB(dbName, a_obs, d_obs)
+                        .then(result => resolve(result))
+                        .catch(error => reject(error))
                     db.close();
                 }
             });
         },
 
-        openDB: function (dbName = this.defaultDB) {
+        openDB: function(dbName = this.defaultDB) {
             return new Promise((resolve, reject) => {
                 var idb = indexedDB.open(dbName);
-                idb.onerror = (event) => reject("Error in opening IndexedDB!");
+                idb.onerror = (event) => reject("Error in opening IndexedDB");
+                idb.onupgradeneeded = (event) => {
+                    event.target.result.close();
+                    this.deleteDB(dbName)
+                    reject("Datebase not found")
+                }
                 idb.onsuccess = (event) => resolve(event.target.result);
             });
         },
 
-        deleteDB: function (dbName = this.defaultDB) {
+        deleteDB: function(dbName = this.defaultDB) {
             return new Promise((resolve, reject) => {
                 var deleteReq = indexedDB.deleteDatabase(dbName);;
                 deleteReq.onerror = (event) => reject("Error deleting database!");
@@ -8437,7 +7779,16 @@ Bitcoin.Util = {
             });
         },
 
-        writeData: function (obsName, data, key = false, dbName = this.defaultDB) {
+        getDBversion: function(dbName = this.defaultDB) {
+            return new Promise((resolve, reject) => {
+                this.openDB(dbName).then(db => {
+                    resolve(db.version)
+                    db.close()
+                }).catch(error => reject(error))
+            })
+        },
+
+        writeData: function(obsName, data, key = false, dbName = this.defaultDB) {
             return new Promise((resolve, reject) => {
                 this.openDB(dbName).then(db => {
                     var obs = db.transaction(obsName, "readwrite").objectStore(obsName);
@@ -8451,7 +7802,7 @@ Bitcoin.Util = {
             });
         },
 
-        addData: function (obsName, data, key = false, dbName = this.defaultDB) {
+        addData: function(obsName, data, key = false, dbName = this.defaultDB) {
             return new Promise((resolve, reject) => {
                 this.openDB(dbName).then(db => {
                     var obs = db.transaction(obsName, "readwrite").objectStore(obsName);
@@ -8465,7 +7816,7 @@ Bitcoin.Util = {
             });
         },
 
-        removeData: function (obsName, key, dbName = this.defaultDB) {
+        removeData: function(obsName, key, dbName = this.defaultDB) {
             return new Promise((resolve, reject) => {
                 this.openDB(dbName).then(db => {
                     var obs = db.transaction(obsName, "readwrite").objectStore(obsName);
@@ -8479,7 +7830,7 @@ Bitcoin.Util = {
             });
         },
 
-        clearData: function (obsName, dbName = this.defaultDB) {
+        clearData: function(obsName, dbName = this.defaultDB) {
             return new Promise((resolve, reject) => {
                 this.openDB(dbName).then(db => {
                     var obs = db.transaction(obsName, "readwrite").objectStore(obsName);
@@ -8491,7 +7842,7 @@ Bitcoin.Util = {
             });
         },
 
-        readData: function (obsName, key, dbName = this.defaultDB) {
+        readData: function(obsName, key, dbName = this.defaultDB) {
             return new Promise((resolve, reject) => {
                 this.openDB(dbName).then(db => {
                     var obs = db.transaction(obsName, "readonly").objectStore(obsName);
@@ -8505,7 +7856,7 @@ Bitcoin.Util = {
             });
         },
 
-        readAllData: function (obsName, dbName = this.defaultDB) {
+        readAllData: function(obsName, dbName = this.defaultDB) {
             return new Promise((resolve, reject) => {
                 this.openDB(dbName).then(db => {
                     var obs = db.transaction(obsName, "readonly").objectStore(obsName);
@@ -8527,18 +7878,30 @@ Bitcoin.Util = {
             });
         },
 
-        searchData: function (obsName, patternEval, dbName = this.defaultDB) {
+        searchData: function(obsName, options = {}, dbName = this.defaultDB) {
+            options.lowerKey = options.atKey || options.lowerKey || 0
+            options.upperKey = options.atKey || options.upperKey || false
+            options.patternEval = options.patternEval || ((k, v) => {
+                return true
+            })
+            options.lastOnly = options.lastOnly || false
             return new Promise((resolve, reject) => {
                 this.openDB(dbName).then(db => {
                     var obs = db.transaction(obsName, "readonly").objectStore(obsName);
                     var filteredResult = {}
-                    let curReq = obs.openCursor();
+                    let curReq = obs.openCursor(
+                        options.upperKey ? IDBKeyRange.bound(options.lowerKey, options
+                            .upperKey) : IDBKeyRange.lowerBound(options.lowerKey),
+                        options.lastOnly ? "prev" : "next");
                     curReq.onsuccess = (evt) => {
                         var cursor = evt.target.result;
                         if (cursor) {
-                            if (patternEval(cursor.primaryKey, cursor.value))
+                            if (options.patternEval(cursor.primaryKey, cursor.value)) {
                                 filteredResult[cursor.primaryKey] = cursor.value;
-                            cursor.continue();
+                                options.lastOnly ? resolve(filteredResult) : cursor
+                                    .continue();
+                            } else
+                                cursor.continue();
                         } else
                             resolve(filteredResult);
                     }
@@ -8551,71 +7914,320 @@ Bitcoin.Util = {
         }
     }
 </script>
-<script id="floCloudAPI">
+<script id="floCloudAPI" version="2.0.2e">
     /* FLO Cloud operations to send/request application data*/
     const floCloudAPI = {
 
         util: {
 
-            lastCommit: {},
+            kBucket: {
+                SNKB: null,
+                SNCO: null,
 
-            resetData: function (dataSet) {
-                try {
-                    dataSet = JSON.parse(dataSet);
-                    console.log(dataSet)
-                    for (vc in dataSet) {
-                        var message = dataSet[vc].message;
-                        if (message.reset) {
-                            floGlobals.appObjects[message.object] = message.reset
-                            floGlobals.vectorClock[message.object] = vc
-                            compactIDB.writeData("appObjects", floGlobals.appObjects[message.object], message
-                                .object)
-                            compactIDB.writeData("vectorClock", vc, message.object)
-                        }
+                util: {
+                    decodeID(floID) {
+                        let k = bitjs.Base58.decode(floID)
+                        k.shift()
+                        k.splice(-4, 4)
+                        const decodedId = Crypto.util.bytesToHex(k);
+                        const nodeIdBigInt = new BigInteger(decodedId, 16);
+                        const nodeIdBytes = nodeIdBigInt.toByteArrayUnsigned();
+                        const nodeIdNewInt8Array = new Uint8Array(nodeIdBytes);
+                        return nodeIdNewInt8Array;
+                    },
+
+                    addNode: function(floID, KB) {
+                        let decodedId = this.decodeID(floID);
+                        const contact = {
+                            id: decodedId,
+                            floID: floID
+                        };
+                        KB.add(contact)
+                    },
+
+                    removeNode: function(floID, KB) {
+                        let decodedId = this.decodeID(floID);
+                        KB.remove(decodedId)
+                    },
+
+                    isPresent: function(floID, KB) {
+                        let kArray = KB.toArray().map(k => k.floID);
+                        return kArray.includes(floID)
+                    },
+
+                    distanceOf: function(floID, KB) {
+                        let decodedId = this.decodeID(floID);
+                        return KB.distance(KB.localNodeId, decodedId);
+                    },
+
+                    closestOf: function(floID, n, KB) {
+                        let decodedId = this.decodeID(floID);
+                        return KB.closest(decodedId, n)
+                    },
+
+                    constructKB: function(list, refID) {
+                        const KBoptions = {
+                            localNodeId: this.decodeID(refID)
+                        };
+                        let KB = new BuildKBucket(KBoptions);
+                        for (let id of list)
+                            this.addNode(id, KB)
+                        return KB;
                     }
-                } catch (error) {
-                    console.error(error)
+                },
+
+                launch: function() {
+                    return new Promise((resolve, reject) => {
+                        try {
+                            let superNodeList = Object.keys(floGlobals.supernodes);
+                            let masterID = floGlobals.SNStorageID;
+                            this.SNKB = this.util.constructKB(superNodeList, masterID);
+                            this.SNCO = superNodeList.map(sn => [this.util.distanceOf(sn, this.SNKB),
+                                    sn
+                                ])
+                                .sort((a, b) => a[0] - b[0])
+                                .map(a => a[1])
+                            resolve('Supernode KBucket formed');
+                        } catch (error) {
+                            reject(error);
+                        }
+                    });
+                },
+
+                innerNodes: function(id1, id2) {
+                    if (!this.SNCO.includes(id1) || !this.SNCO.includes(id2))
+                        throw Error('Given nodes are not supernode');
+                    let iNodes = []
+                    for (let i = this.SNCO.indexOf(id1) + 1; this.SNCO[i] != id2; i++) {
+                        if (i < this.SNCO.length)
+                            iNodes.push(this.SNCO[i])
+                        else i = -1
+                    }
+                    return iNodes
+                },
+
+                outterNodes: function(id1, id2) {
+                    if (!this.SNCO.includes(id1) || !this.SNCO.includes(id2))
+                        throw Error('Given nodes are not supernode');
+                    let oNodes = []
+                    for (let i = this.SNCO.indexOf(id2) + 1; this.SNCO[i] != id1; i++) {
+                        if (i < this.SNCO.length)
+                            oNodes.push(this.SNCO[i])
+                        else i = -1
+                    }
+                    return oNodes
+                },
+
+                prevNode: function(id, N = 1) {
+                    let n = N || this.SNCO.length;
+                    if (!this.SNCO.includes(id))
+                        throw Error('Given node is not supernode');
+                    let pNodes = []
+                    for (let i = 0, j = this.SNCO.indexOf(id) - 1; i < n; j--) {
+                        if (j == this.SNCO.indexOf(id))
+                            break;
+                        else if (j > -1)
+                            pNodes[i++] = this.SNCO[j]
+                        else j = this.SNCO.length
+                    }
+                    return (N == 1 ? pNodes[0] : pNodes)
+                },
+
+                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))
+                            break;
+                        else if (j < this.SNCO.length)
+                            nNodes[i++] = this.SNCO[j]
+                        else j = -1
+                    }
+                    return (N == 1 ? nNodes[0] : nNodes)
+                },
+
+                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)
                 }
             },
 
-            updateData: function (dataSet) {
-                try {
-                    dataSet = JSON.parse(dataSet);
-                    console.log(dataSet)
-                    for (vc in dataSet) {
-                        var message = dataSet[vc].message;
-                        if (message.diff) {
-                            floGlobals.appObjects[message.object] = mergeDifference(floGlobals.appObjects[
-                                message.object], message.diff)
-                            compactIDB.writeData("appObjects", floGlobals.appObjects[message.object], message
-                                .object)
+            inactive: new Set(),
+            connect(snID) {
+                return new Promise((resolve, reject) => {
+                    if (!(snID in floGlobals.supernodes))
+                        return reject(`${snID} is not a supernode`)
+                    let inactive = this.inactive
+                    if (inactive.has(snID))
+                        return reject(`${snID} is not active`)
+                    var wsConn = new WebSocket("wss://" + floGlobals.supernodes[snID].uri + "/ws");
+                    wsConn.onmessage = (evt) => {
+                        if (evt.data == '$+')
+                            resolve(wsConn)
+                        else if (evt.data == '$-') {
+                            wsConn.close();
+                            inactive.add(snID)
+                            reject(`${snID} is not active`)
                         }
-                        floGlobals.vectorClock[message.object] = vc
-                        compactIDB.writeData("vectorClock", vc, message.object)
                     }
-                } catch (error) {
-                    console.error(error)
-                }
+                    wsConn.onerror = evt => {
+                        inactive.add(snID)
+                        reject(`${snID} is unavailable`)
+                    }
+                })
             },
 
-            storeGeneralData: function (filterStr, dataSet) {
-                try {
-                    dataSet = JSON.parse(dataSet);
-                    console.log(dataSet)
-                    if (!Array.isArray(floGlobals.generalData[filterStr]))
-                        floGlobals.generalData[filterStr] = []
-                    for (vc in dataSet) {
-                        floGlobals.generalData[filterStr].push({
-                            sender: dataSet[vc].senderID,
-                            vectorClock: vc,
-                            message: dataSet[vc].message,
-                            sign: dataSet[vc].sign,
-                            pubKey: dataSet[vc].pubKey
+            connectActive(snID, reverse = false) {
+                return new Promise((resolve, reject) => {
+                    if (this.inactive.size === this.kBucket.SNCO.length)
+                        return reject('Cloud offline')
+                    if (!(snID in floGlobals.supernodes))
+                        snID = this.kBucket.closestNode(snID);
+                    this.connect(snID)
+                        .then(node => resolve(node))
+                        .catch(error => {
+                            if (reverse)
+                                var nxtNode = this.kBucket.prevNode(snID);
+                            else
+                                var nxtNode = this.kBucket.nextNode(snID);
+                            this.connectActive(nxtNode, reverse)
+                                .then(node => resolve(node))
+                                .catch(error => reject(error))
                         })
-                        compactIDB.writeData("generalData", floGlobals.generalData[filterStr], filterStr)
-                        floGlobals.generalVC[filterStr] = vc
-                        compactIDB.writeData("generalVC", vc, filterStr)
+                })
+            },
+
+            singleRequest: function(floID, data) {
+                return new Promise((resolve, reject) => {
+                    this.connectActive(floID).then(node => {
+                        let randID = floCrypto.randString(5);
+                        node.send(`${floID}|${randID}:${JSON.stringify(data)}`);
+                        node.onmessage = (evt) => {
+                            if (evt.data.startsWith(randID, 1)) {
+                                try {
+                                    let data = JSON.parse(evt.data.substring(42))
+                                    resolve(data)
+                                } catch (error) {
+                                    reject(evt.data.substring(42))
+                                } finally {
+                                    node.close()
+                                }
+                            }
+                        }
+                    }).catch(error => reject(error));
+                });
+            },
+
+            liveRequest: function(floID, datareq, callback) {
+                let request = {
+                    ...datareq.request
+                };
+                const checkFilter = (v, d, r) =>
+                    (!r.atVectorClock || r.atVectorClock == v) &&
+                    (r.atVectorClock || !r.lowerVectorClock || r.lowerVectorClock <= v) &&
+                    (r.atVectorClock || !r.upperVectorClock || r.upperVectorClock >= v) &&
+                    r.application == d.application &&
+                    r.receiverID == d.receiverID &&
+                    (!r.comment || r.comment == d.comment) &&
+                    (!r.type || r.type == d.type) &&
+                    (!r.senderIDs || r.senderIDs.includes(d.senderID));
+                return new Promise((resolve, reject) => {
+                    this.connectActive(floID).then(node => {
+                        let randID = floCrypto.randString(5);
+                        node.send(`${floID}|${randID}:${JSON.stringify(datareq)}`);
+                        node.onmessage = (evt) => {
+                            if (evt.data.startsWith(randID, 1))
+                                var i = 42
+                            else if (evt.data.startsWith(floID, 1))
+                                var i = 36
+                            else return;
+                            let d = e = null;
+                            try {
+                                let data = JSON.parse(evt.data.substring(i))
+                                let filter = {}
+                                for (let v in data)
+                                    if (checkFilter(v, data[v], request))
+                                        filter[v] = data[v]
+                                d = filter
+                            } catch (error) {
+                                e = evt.data.substring(i)
+                            } finally {
+                                callback(d, e)
+                            }
+                        }
+                        this.liveRequest[randID] = node;
+                        this.liveRequest[randID].request = request;
+                        resolve(randID)
+                    }).catch(error => reject(error));
+                });
+            },
+
+            encodeMessage: function(message) {
+                return btoa(unescape(encodeURIComponent(JSON.stringify(message))))
+            },
+
+            decodeMessage: function(message) {
+                return JSON.parse(decodeURIComponent(escape(atob(message))))
+            },
+
+            filterKey: function(type, options) {
+                return type + (options.comment ? ':' + options.comment : '') +
+                    '|' + (options.receiverID || floGlobals.adminID) +
+                    '|' + (options.application || floGlobals.application);
+            },
+
+            lastCommit: function(method, objName) {
+                switch (method) {
+                    case "GET":
+                        return JSON.parse(this.lastCommit[objName]);
+                    case "SET":
+                        this.lastCommit[objName] = JSON.stringify(floGlobals.appObjects[objName]);
+                }
+            },
+
+            updateObject: function(dataSet) {
+                try {
+                    console.log(dataSet)
+                    let updatedObjects = new Set()
+                    for (vc in dataSet) {
+                        switch (dataSet[vc].comment) {
+                            case "RESET":
+                                if (dataSet[vc].message.reset)
+                                    floGlobals.appObjects[dataSet[vc].type] = dataSet[vc].message.reset;
+                                break;
+                            case "UPDATE":
+                                if (dataSet[vc].message.update)
+                                    floGlobals.appObjects[dataSet[vc].type] = mergeDiff(floGlobals
+                                        .appObjects[dataSet[vc].type], message.diff)
+                        }
+                        floGlobals.lastVC[dataSet[vc].type] = vc;
+                        updatedObjects.add(dataSet[vc].type)
                     }
+                    updatedObjects.forEach(o => {
+                        compactIDB.writeData("appObjects", floGlobals.appObjects[o], o)
+                        compactIDB.writeData("lastVC", floGlobals.lastVC[o], o)
+                    });
+                } catch (error) {
+                    console.error(error)
+                }
+            },
+
+            storeGeneral: function(fk, dataSet) {
+                try {
+                    console.log(dataSet)
+                    if (typeof floGlobals.generalData[fk] !== "object")
+                        floGlobals.generalData[fk] = {}
+                    for (let vc in dataSet)
+                        floGlobals.generalData[fk][vc] = dataSet[vc];
+                    floGlobals.lastVC[fk] = Object.keys(floGlobals.generalData[fk]).sort().pop()
+                    compactIDB.writeData("lastVC", floGlobals.lastVC[fk], fk)
+                    compactIDB.writeData("generalData", floGlobals.generalData[fk], fk)
                 } catch (error) {
                     console.error(error)
                 }
@@ -8623,151 +8235,482 @@ Bitcoin.Util = {
         },
 
         //send Any message to supernode cloud storage
-        sendApplicationData: function (message, type, options = {}) {
+        sendApplicationData: function(message, type, options = {}) {
             return new Promise((resolve, reject) => {
                 var data = {
                     senderID: myFloID,
                     receiverID: options.receiverID || floGlobals.adminID,
                     pubKey: myPubKey,
-                    message: message,
-                    sign: floCrypto.signData(JSON.stringify(message), myPrivKey),
+                    message: this.util.encodeMessage(message),
+                    time: Date.now(),
                     application: options.application || floGlobals.application,
                     type: type,
                     comment: options.comment || ""
                 }
-                floSupernode.sendData(JSON.stringify(data), data.receiverID)
-                    .then(result => resolve(result))
-                    .catch(error => reject(error))
+                let hashcontent = ["receiverID", "time", "application", "type", "message", "comment"]
+                    .map(d => data[d]).join("|")
+                data.sign = floCrypto.signData(hashcontent, myPrivKey)
+                this.util.singleRequest(data.receiverID, data)
+                    .then(result => {
+                        data.message = message
+                        resolve({
+                            [result.vectorClock]: data
+                        })
+                    }).catch(error => reject(error))
             })
         },
 
         //request any data from supernode cloud
-        requestApplicationData: function (options = {}) {
+        requestApplicationData: function(type, options = {}) {
             return new Promise((resolve, reject) => {
                 var request = {
                     receiverID: options.receiverID || floGlobals.adminID,
                     senderIDs: options.senderIDs || undefined,
                     application: options.application || floGlobals.application,
-                    type: options.type || undefined,
+                    type: type,
                     comment: options.comment || undefined,
                     lowerVectorClock: options.lowerVectorClock || undefined,
                     upperVectorClock: options.upperVectorClock || undefined,
                     atVectorClock: options.atVectorClock || undefined,
                     mostRecent: options.mostRecent || undefined,
                 }
-                floSupernode.requestData(JSON.stringify(request), request.receiverID)
-                    .then(response => resolve(response))
-                    .catch(error => reject(error))
+                var datareq = {
+                    time: Date.now(),
+                    request
+                }
+                if (options.callback instanceof Function) {
+                    let callback = (d, e) => {
+                        for (let v in d)
+                            d[v].message = this.util.decodeMessage(d[v].message)
+                        options.callback(d, e)
+                    }
+                    this.util.liveRequest(request.receiverID, datareq, callback)
+                        .then(result => resolve(result))
+                        .catch(error => reject(error))
+                } else {
+                    this.util.singleRequest(request.receiverID, datareq).then(data => {
+                        for (let v in data)
+                            data[v].message = this.util.decodeMessage(data[v].message)
+                        resolve(data)
+                    }).catch(error => reject(error))
+                }
+            })
+        },
+
+        //delete data from supernode cloud (received only)
+        deleteApplicationData: function(vectorClocks, options = {}) {
+            return new Promise((resolve, reject) => {
+                var delreq = {
+                    requestorID: myFloID,
+                    pubKey: myPubKey,
+                    time: Date.now(),
+                    delete: (Array.isArray(vectorClocks) ? vectorClocks : [vectorClocks]),
+                    application: options.application || floGlobals.application
+                }
+                let hashcontent = ["time", "application", "delete"]
+                    .map(d => delreq[d]).join("|")
+                delreq.sign = floCrypto.signData(hashcontent, myPrivKey)
+                this.util.singleRequest(delreq.requestorID, delreq).then(result => {
+                    let success = [],
+                        failed = [];
+                    result.forEach(r => r.status === 'fulfilled' ?
+                        success.push(r.value) : failed.push(r.reason));
+                    resolve({
+                        success,
+                        failed
+                    })
+                }).catch(error => reject(error))
+            })
+        },
+
+        //edit comment of data in supernode cloud (mutable comments only)
+        editApplicationData: function(vectorClock, newComment, oldData, options = {}) {
+            return new Promise((resolve, reject) => {
+                let p0
+                if (!oldData) {
+                    options.atVectorClock = vectorClock;
+                    options.callback = false;
+                    p0 = this.requestApplicationData(false, options)
+                } else
+                    p0 = Promise.resolve({
+                        vectorClock: {
+                            ...oldData
+                        }
+                    })
+                p0.then(d => {
+                    if (d.senderID != myFloID)
+                        return reject("Invalid requestorID")
+                    else if (!d.comment.startsWith("EDIT:"))
+                        return reject("Data immutable")
+                    let data = {
+                        requestorID: myFloID,
+                        receiverID: d.receiverID,
+                        time: Date.now(),
+                        application: d.application,
+                        edit: {
+                            vectorClock: vectorClock,
+                            comment: newComment
+                        }
+                    }
+                    d.comment = data.edit.comment;
+                    let hashcontent = ["receiverID", "time", "application", "type", "message",
+                            "comment"
+                        ]
+                        .map(x => d[x]).join("|")
+                    data.edit.sign = floCrypto.signData(hashcontent, myPrivKey)
+                    this.util.singleRequest(data.receiverID, data)
+                        .then(result => resolve("Data comment updated"))
+                        .catch(error => reject(error))
+                })
+            })
+        },
+
+        //mark data in supernode cloud (subAdmin access only)
+        markApplicationData: function(mark, options = {}) {
+            return new Promise((resolve, reject) => {
+                if (!floGlobals.subAdmins.includes(myFloID))
+                    return reject("Only subAdmins can mark data")
+                if (typeof mark !== "object") {
+                    if (!Array.isArray(mark)) mark = [mark];
+                    let tmp = {}
+                    mark.forEach(vc => tmp[vc] = true)
+                    mark = tmp;
+                }
+                var markreq = {
+                    receiverID: options.receiverID || floGlobals.adminID,
+                    requestorID: myFloID,
+                    pubKey: myPubKey,
+                    time: Date.now(),
+                    mark: mark,
+                    application: options.application || floGlobals.application
+                }
+                let hashcontent = ["time", "application"]
+                    .map(d => markreq[d]).join("|") + JSON.stringify(markreq.mark)
+                markreq.sign = floCrypto.signData(hashcontent, myPrivKey)
+                this.util.singleRequest(markreq.requestorID, markreq).then(result => {
+                    let success = [],
+                        failed = [];
+                    result.forEach(r => r.status === 'fulfilled' ?
+                        success.push(r.value) : failed.push(r.reason));
+                    resolve({
+                        success,
+                        failed
+                    })
+                }).catch(error => reject(error))
             })
         },
 
         //send General Data
-        sendGeneralData: function (message, type, options = {}) {
+        sendGeneralData: function(message, type, options = {}) {
             return new Promise((resolve, reject) => {
-                if(options.encrypt){
-                    let encryptionKey = (options.encrypt === true) ? floGlobals.settings.encryptionKey : options.encrypt
+                if (options.encrypt) {
+                    let encryptionKey = options.encrypt === true ?
+                        floGlobals.settings.encryptionKey : options.encrypt
                     message = floCrypto.encryptData(JSON.stringify(message), encryptionKey)
                 }
-                this.sendApplicationData(message, type, options)
-                    .then(result => resolve(result))
-                    .catch(error => reject(error))
+                this.sendApplicationData(message, type, options).then(result => {
+                    //options.comment = null;
+                    //var fk = this.util.filterKey(type, options)
+                    //this.util.storeGeneral(fk, result)
+                    resolve(result)
+                }).catch(error => reject(error))
             })
         },
 
         //request General Data
-        requestGeneralData: function (type, options = {}) {
+        requestGeneralData: function(type, options = {}) {
             return new Promise((resolve, reject) => {
-                var filterStr = JSON.stringify({
-                    application: options.application || floGlobals.application,
-                    type: type,
-                    comment: options.comment
-                })
-                options.type = type
-                options.lowerVectorClock = options.lowerVectorClock || floGlobals.generalVC[filterStr] +
-                    1
-                this.requestApplicationData(options).then(dataSet => {
-                    this.util.storeGeneralData(filterStr, dataSet)
-                    resolve('General Data Updated')
-                }).catch(error => reject(error))
+                var fk = this.util.filterKey(type, options)
+                options.lowerVectorClock = options.lowerVectorClock || floGlobals.lastVC[fk] + 1;
+                if (options.callback instanceof Function) {
+                    let new_options = Object.create(options)
+                    new_options.callback = (d, e) => {
+                        this.util.storeGeneral(fk, d);
+                        options.callback(d, e)
+                    }
+                    this.requestApplicationData(type, new_options)
+                        .then(result => resolve(result))
+                        .catch(error => reject(error))
+                } else {
+                    this.requestApplicationData(type, options).then(dataSet => {
+                        this.util.storeGeneral(fk, dataSet)
+                        resolve(dataSet)
+                    }).catch(error => reject(error))
+                }
             })
         },
 
         //request an object data from supernode cloud
-        requestObjectData: function (objectName, options = {}) {
+        requestObjectData: function(objectName, options = {}) {
             return new Promise((resolve, reject) => {
-                var request = {
-                    receiverID: options.receiverID || floGlobals.adminID,
-                    senderIDs: (options.senderIDs === false) ? false : options.senderIDs ||
-                        floGlobals.subAdmins,
-                    application: options.application || floGlobals.application,
-                    comment: options.comment,
-                    type: `${objectName}@Reset`,
-                    lowerVectorClock: floGlobals.vectorClock[objectName] + 1,
-                    mostRecent: true
+                options.lowerVectorClock = options.lowerVectorClock || floGlobals.lastVC[objectName] +
+                    1;
+                options.senderIDs = [false, null].includes(options.senderIDs) ? null :
+                    options.senderIDs || floGlobals.subAdmins;
+                options.mostRecent = true;
+                options.comment = 'RESET';
+                let callback = null;
+                if (options.callback instanceof Function) {
+                    callback = (d, e) => {
+                        this.util.updateObject(d);
+                        options.callback(d, e);
+                    }
+                    delete options.callback;
                 }
-                floSupernode.requestData(JSON.stringify(request), request.receiverID).then(dataSet => {
-                    this.util.resetData(dataSet)
-                    request.type = `${objectName}@Update`
-                    request.lowerVectorClock = floGlobals.vectorClock[objectName] + 1
-                    request.mostRecent = false
-                    floSupernode.requestData(JSON.stringify(request), request.receiverID).then(
-                        dataSet => {
-                            this.util.updateData(dataSet)
-                            this.util.lastCommit[objectName] = JSON.stringify(floGlobals
-                                .appObjects[objectName])
-                            resolve('Object Data Updated')
+                this.requestApplicationData(objectName, options).then(dataSet => {
+                    this.util.updateObject(dataSet)
+                    delete options.comment;
+                    options.lowerVectorClock = floGlobals.lastVC[objectName] + 1
+                    delete options.mostRecent;
+                    if (callback) {
+                        let new_options = Object.create(options)
+                        new_options.callback = callback;
+                        this.requestApplicationData(objectName, new_options)
+                            .then(result => resolve(result))
+                            .catch(error => reject(error))
+                    } else {
+                        this.requestApplicationData(objectName, options).then(dataSet => {
+                            this.util.updateObject(dataSet)
+                            this.util.lastCommit("SET", objectName)
+                            resolve(floGlobals.appObjects[objectName])
                         }).catch(error => reject(error))
+                    }
                 }).catch(error => reject(error))
             })
         },
 
-        //reset or initialize an object and send it to cloud
-        resetObjectData: function (objectName, options = {}) {
+        closeRequest: function(requestID) {
             return new Promise((resolve, reject) => {
-                var message = {
-                    division: options.division || floGlobals.division,
-                    object: objectName,
-                    vectorClock: floGlobals.vectorClock[objectName],
+                let conn = this.util.liveRequest[requestID]
+                if (!conn)
+                    return reject('Request not found')
+                conn.onclose = evt => {
+                    delete this.util.liveRequest[requestID]
+                    resolve('Request connection closed')
+                }
+                conn.close()
+            })
+        },
+
+        //reset or initialize an object and send it to cloud
+        resetObjectData: function(objectName, options = {}) {
+            return new Promise((resolve, reject) => {
+                let message = {
                     reset: floGlobals.appObjects[objectName]
                 }
-                this.sendApplicationData(message, `${objectName}@Reset`, options).then(result => {
-                    this.util.lastCommit[objectName] = JSON.stringify(floGlobals.appObjects[
-                        objectName])
+                options.comment = 'RESET';
+                this.sendApplicationData(message, objectName, options).then(result => {
+                    this.util.lastCommit("SET", objectName)
                     resolve(result)
                 }).catch(error => reject(error))
             })
         },
 
         //update the diff and send it to cloud
-        updateObjectData: function (objectName, options = {}) {
+        updateObjectData: function(objectName, options = {}) {
             return new Promise((resolve, reject) => {
-                var message = {
-                    division: options.division || floGlobals.division,
-                    object: objectName,
-                    vectorClock: floGlobals.vectorClock[objectName],
-                    diff: findDifference(JSON.parse(this.util.lastCommit[objectName]), floGlobals
-                        .appObjects[objectName])
-                }
-                this.sendApplicationData(message, `${objectName}@Update`, options).then(result => {
-                    this.util.lastCommit[objectName] = JSON.stringify(floGlobals.appObjects[
+                let message = {
+                    diff: findDiff(this.util.lastCommit("GET", objectName), floGlobals.appObjects[
                         objectName])
+                }
+                options.comment = 'UPDATE';
+                this.sendApplicationData(message, objectName, options).then(result => {
+                    this.util.lastCommit("SET", objectName)
                     resolve(result)
                 }).catch(error => reject(error))
             })
         }
     }
-</script>
 
-<script id="floDapps">
+    /*Kademlia DHT K-bucket implementation as a binary tree.*/
+    function BuildKBucket(options = {}) {
+        this.localNodeId = options.localNodeId || window.crypto.getRandomValues(new Uint8Array(20))
+        this.numberOfNodesPerKBucket = options.numberOfNodesPerKBucket || 20
+        this.numberOfNodesToPing = options.numberOfNodesToPing || 3
+        this.distance = options.distance || this.distance
+        this.arbiter = options.arbiter || this.arbiter
+        this.metadata = Object.assign({}, options.metadata)
+
+        this.createNode = function() {
+            return {
+                contacts: [],
+                dontSplit: false,
+                left: null,
+                right: null
+            }
+        }
+
+        this.ensureInt8 = function(name, val) {
+            if (!(val instanceof Uint8Array))
+                throw new TypeError(name + ' is not a Uint8Array')
+        }
+
+        this.arrayEquals = function(array1, array2) {
+            if (array1 === array2)
+                return true
+            if (array1.length !== array2.length)
+                return false
+            for (let i = 0, length = array1.length; i < length; ++i)
+                if (array1[i] !== array2[i])
+                    return false
+            return true
+        }
+
+        this.ensureInt8('option.localNodeId as parameter 1', this.localNodeId)
+        this.root = this.createNode()
+
+        this.arbiter = function(incumbent, candidate) {
+            return incumbent.vectorClock > candidate.vectorClock ? incumbent : candidate
+        }
+
+        this.distance = function(firstId, secondId) {
+            let distance = 0
+            let i = 0
+            const min = Math.min(firstId.length, secondId.length)
+            const max = Math.max(firstId.length, secondId.length)
+            for (; i < min; ++i)
+                distance = distance * 256 + (firstId[i] ^ secondId[i])
+            for (; i < max; ++i) distance = distance * 256 + 255
+            return distance
+        }
+
+        this.add = function(contact) {
+            this.ensureInt8('contact.id', (contact || {}).id)
+            let bitIndex = 0
+            let node = this.root
+            while (node.contacts === null)
+                node = this._determineNode(node, contact.id, bitIndex++)
+            const index = this._indexOf(node, contact.id)
+            if (index >= 0) {
+                this._update(node, index, contact)
+                return this
+            }
+            if (node.contacts.length < this.numberOfNodesPerKBucket) {
+                node.contacts.push(contact)
+                return this
+            }
+            if (node.dontSplit)
+                return this
+            this._split(node, bitIndex)
+            return this.add(contact)
+        }
+
+        this.closest = function(id, n = Infinity) {
+            this.ensureInt8('id', id)
+            if ((!Number.isInteger(n) && n !== Infinity) || n <= 0)
+                throw new TypeError('n is not positive number')
+            let contacts = []
+            for (let nodes = [this.root], bitIndex = 0; nodes.length > 0 && contacts.length < n;) {
+                const node = nodes.pop()
+                if (node.contacts === null) {
+                    const detNode = this._determineNode(node, id, bitIndex++)
+                    nodes.push(node.left === detNode ? node.right : node.left)
+                    nodes.push(detNode)
+                } else
+                    contacts = contacts.concat(node.contacts)
+            }
+            return contacts
+                .map(a => [this.distance(a.id, id), a])
+                .sort((a, b) => a[0] - b[0])
+                .slice(0, n)
+                .map(a => a[1])
+        }
+
+        this.count = function() {
+            let count = 0
+            for (const nodes = [this.root]; nodes.length > 0;) {
+                const node = nodes.pop()
+                if (node.contacts === null)
+                    nodes.push(node.right, node.left)
+                else
+                    count += node.contacts.length
+            }
+            return count
+        }
+
+        this._determineNode = function(node, id, bitIndex) {
+            const bytesDescribedByBitIndex = bitIndex >> 3
+            const bitIndexWithinByte = bitIndex % 8
+            if ((id.length <= bytesDescribedByBitIndex) && (bitIndexWithinByte !== 0))
+                return node.left
+            const byteUnderConsideration = id[bytesDescribedByBitIndex]
+            if (byteUnderConsideration & (1 << (7 - bitIndexWithinByte)))
+                return node.right
+            return node.left
+        }
+
+        this.get = function(id) {
+            this.ensureInt8('id', id)
+            let bitIndex = 0
+            let node = this.root
+            while (node.contacts === null)
+                node = this._determineNode(node, id, bitIndex++)
+            const index = this._indexOf(node, id)
+            return index >= 0 ? node.contacts[index] : null
+        }
+
+        this._indexOf = function(node, id) {
+            for (let i = 0; i < node.contacts.length; ++i)
+                if (this.arrayEquals(node.contacts[i].id, id))
+                    return i
+            return -1
+        }
+
+        this.remove = function(id) {
+            this.ensureInt8('the id as parameter 1', id)
+            let bitIndex = 0
+            let node = this.root
+            while (node.contacts === null)
+                node = this._determineNode(node, id, bitIndex++)
+            const index = this._indexOf(node, id)
+            if (index >= 0)
+                node.contacts.splice(index, 1)[0]
+            return this
+        }
+
+        this._split = function(node, bitIndex) {
+            node.left = this.createNode()
+            node.right = this.createNode()
+            for (const contact of node.contacts)
+                this._determineNode(node, contact.id, bitIndex).contacts.push(contact)
+            node.contacts = null
+            const detNode = this._determineNode(node, this.localNodeId, bitIndex)
+            const otherNode = node.left === detNode ? node.right : node.left
+            otherNode.dontSplit = true
+        }
+
+        this.toArray = function() {
+            let result = []
+            for (const nodes = [this.root]; nodes.length > 0;) {
+                const node = nodes.pop()
+                if (node.contacts === null)
+                    nodes.push(node.right, node.left)
+                else
+                    result = result.concat(node.contacts)
+            }
+            return result
+        }
+
+        this._update = function(node, index, contact) {
+            if (!this.arrayEquals(node.contacts[index].id, contact.id))
+                throw new Error('wrong index for _update')
+            const incumbent = node.contacts[index]
+            const selection = this.arbiter(incumbent, contact)
+            if (selection === incumbent && incumbent !== contact) return
+            node.contacts.splice(index, 1)
+            node.contacts.push(selection)
+        }
+    }
+</script>
+<script id="floDapps" version="2.0.1b">
     /* General functions for FLO Dapps*/
     const floDapps = {
 
         util: {
-            appObs: {},
 
-            initIndexedDB: function () {
+            initIndexedDB: function() {
                 return new Promise((resolve, reject) => {
-                    var obj = {
+                    var obs_g = {
                         //general
                         lastTx: {},
                         //supernode (cloud list)
@@ -8776,368 +8719,447 @@ Bitcoin.Util = {
                                 uri: null,
                                 pubKey: null
                             }
-                        },
+                        }
+                    }
+                    var obs_a = {
                         //login credentials
                         credentials: {},
                         //for Dapps
                         subAdmins: {},
                         settings: {},
                         appObjects: {},
-                        vectorClock: {},
                         generalData: {},
-                        generalVC: {},
-
-                        //bankApp
-                        collaterals: {},
+                        lastVC: {}
                     }
                     //add other given objectStores
-                    for (o in this.appObs)
-                        if (!(o in obj))
-                            obj[o] = this.appObs[o]
-                    compactIDB.initDB(floGlobals.application, obj).then(result => {
+                    this.initIndexedDB.appObs = this.initIndexedDB.appObs || {}
+                    for (o in this.initIndexedDB.appObs)
+                        if (!(o in obs_a))
+                            obs_a[o] = this.initIndexedDB.appObs[o]
+                    Promise.all([
+                        compactIDB.initDB(floGlobals.application, obs_a),
+                        compactIDB.initDB("floDapps", obs_g)
+                    ]).then(result => {
+                        compactIDB.setDefaultDB(floGlobals.application)
                         resolve("IndexedDB App Storage Initated Successfully")
                     }).catch(error => reject(error));
                 })
             },
 
+            initUserDB: function(floID) {
+                return new Promise((resolve, reject) => {
+                    var obs = {
+                        contacts: {},
+                        pubKeys: {},
+                        messages: {}
+                    }
+                    compactIDB.initDB(`floDapps#${floID}`, obs).then(result => {
+                        resolve("UserDB Initated Successfully")
+                    }).catch(error => reject('Init userDB failed'));
+                })
+            },
+
+            loadUserDB: function(floID) {
+                return new Promise((resolve, reject) => {
+                    var loadData = ["contacts", "pubKeys", "messages"]
+                    var promises = []
+                    for (var i = 0; i < loadData.length; i++)
+                        promises[i] = compactIDB.readAllData(loadData[i], `floDapps#${floID}`)
+                    Promise.all(promises).then(results => {
+                        for (var i = 0; i < loadData.length; i++)
+                            floGlobals[loadData[i]] = results[i]
+                        resolve("Loaded Data from userDB")
+                    }).catch(error => reject('Load userDB failed'))
+                })
+            },
+
             startUpFunctions: {
 
-                readSupernodeListFromAPI: function () {
+                readSupernodeListFromAPI: function() {
                     return new Promise((resolve, reject) => {
-                        compactIDB.readData("lastTx", floGlobals.SNStorageID).then(lastTx => {
+                        compactIDB.readData("lastTx", floGlobals.SNStorageID, "floDapps").then(lastTx => {
                             floBlockchainAPI.readData(floGlobals.SNStorageID, {
                                 ignoreOld: lastTx,
                                 sentOnly: true,
                                 pattern: "SuperNodeStorage"
                             }).then(result => {
                                 for (var i = result.data.length - 1; i >= 0; i--) {
-                                    var content = JSON.parse(result.data[i])
-                                        .SuperNodeStorage;
+                                    var content = JSON.parse(result.data[i]).SuperNodeStorage;
                                     for (sn in content.removeNodes)
-                                        compactIDB.removeData("supernodes", sn);
-                                    for (sn in content.addNodes)
-                                        compactIDB.writeData("supernodes", content
-                                            .addNodes[sn], sn);
+                                        compactIDB.removeData("supernodes", sn, "floDapps");
+                                    for (sn in content.newNodes)
+                                        compactIDB.writeData("supernodes", content.newNodes[sn], sn, "floDapps");
                                 }
-                                compactIDB.writeData("lastTx", result.totalTxs,
-                                    floGlobals.SNStorageID);
-                                compactIDB.readAllData("supernodes").then(result => {
+                                compactIDB.writeData("lastTx", result.totalTxs, floGlobals.SNStorageID, "floDapps");
+                                compactIDB.readAllData("supernodes", "floDapps").then(result => {
                                     floGlobals.supernodes = result;
-
-                                    floSupernode.kBucket.launch(Object.keys(
-                                                floGlobals.supernodes),
-                                            floGlobals.SNStorageID)
-                                        .then(result => resolve(
-                                            "Loaded Supernode list\n" +
-                                            result))
+                                    floCloudAPI.util.kBucket.launch()
+                                        .then(result => resolve("Loaded Supernode list\n" + result))
+                                        .catch(error => reject(error))
                                 })
                             })
                         }).catch(error => reject(error))
                     })
                 },
 
-                readAppConfigFromAPI: function () {
+                readAppConfigFromAPI: function() {
                     return new Promise((resolve, reject) => {
-                        compactIDB.readData("lastTx", floGlobals.adminID).then(lastTx => {
+                        compactIDB.readData("lastTx", `${floGlobals.application}|${floGlobals.adminID}`, "floDapps").then(lastTx => {
                             floBlockchainAPI.readData(floGlobals.adminID, {
                                 ignoreOld: lastTx,
                                 sentOnly: true,
                                 pattern: floGlobals.application
                             }).then(result => {
                                 for (var i = result.data.length - 1; i >= 0; i--) {
-                                    var content = JSON.parse(result.data[i])[floGlobals
-                                        .application];
+                                    var content = JSON.parse(result.data[i])[floGlobals.application];
+                                    if (!content || typeof content !== "object")
+                                        continue;
                                     if (Array.isArray(content.removeSubAdmin))
-                                        for (var j = 0; j < content.removeSubAdmin
-                                            .length; j++)
-                                            compactIDB.removeData("subAdmins", content
-                                                .removeSubAdmin[j]);
+                                        for (var j = 0; j < content.removeSubAdmin.length; j++)
+                                            compactIDB.removeData("subAdmins", content.removeSubAdmin[j]);
                                     if (Array.isArray(content.addSubAdmin))
-                                        for (var k = 0; k < content.addSubAdmin
-                                            .length; k++)
-                                            compactIDB.writeData("subAdmins", true,
-                                                content.addSubAdmin[k]);
+                                        for (var k = 0; k < content.addSubAdmin.length; k++)
+                                            compactIDB.writeData("subAdmins", true, content.addSubAdmin[k]);
                                     if (content.settings)
                                         for (let l in content.settings)
-                                            compactIDB.writeData("settings", content
-                                                .settings[l], l);
-
-                                    for (let c in content.removeCollateral)
-                                        compactIDB.removeData("collaterals", c);
-                                    for (let c in content.addCollateral)
-                                        compactIDB.writeData("collaterals", content
-                                            .addCollateral[c], c);
+                                            compactIDB.writeData("settings", content.settings[l], l)
                                 }
-                                compactIDB.writeData("lastTx", result.totalTxs,
-                                    floGlobals.adminID);
+                                compactIDB.writeData("lastTx", result.totalTxs, `${floGlobals.application}|${floGlobals.adminID}`, "floDapps");
                                 compactIDB.readAllData("subAdmins").then(result => {
                                     floGlobals.subAdmins = Object.keys(result);
-                                    compactIDB.readAllData("settings").then(
-                                        result => {
-                                            floGlobals.settings = result;
-                                            compactIDB.readAllData(
-                                                "collaterals").then(
-                                                result => {
-                                                    floGlobals
-                                                        .collaterals =
-                                                        result;
-                                                    resolve(
-                                                        "Read app configuration from blockchain");
-                                                })
-                                        })
+                                    compactIDB.readAllData("settings").then(result => {
+                                        floGlobals.settings = result;
+                                        resolve("Read app configuration from blockchain");
+                                    })
                                 })
                             })
                         }).catch(error => reject(error))
                     })
                 },
 
-                loadDataFromIDB: function () {
+                loadDataFromAppIDB: function() {
                     return new Promise((resolve, reject) => {
-                        var loadData = ["appObjects", "vectorClock", "generalData", "generalVC"]
+                        var loadData = ["appObjects", "generalData", "lastVC"]
                         var promises = []
                         for (var i = 0; i < loadData.length; i++)
                             promises[i] = compactIDB.readAllData(loadData[i])
                         Promise.all(promises).then(results => {
                             for (var i = 0; i < loadData.length; i++)
                                 floGlobals[loadData[i]] = results[i]
-                            resolve("Loaded Data from IDB")
-                        }).catch(error => reject(error))
-                    })
-                },
-
-                getCredentials: function () {
-
-                    const defaultInput = function (type) {
-                        return new Promise((resolve, reject) => {
-                            let inputVal = prompt(`Enter ${type}: `)
-                            if (inputVal === null)
-                                reject(null)
-                            else
-                                resolve(inputVal)
-                        })
-                    }
-
-                    const inputFn = this.getCredentials.privKeyInput || defaultInput;
-
-                    const readSharesFromIDB = function (indexArr) {
-                        return new Promise((resolve, reject) => {
-                            var promises = []
-                            for (var i = 0; i < indexArr.length; i++)
-                                promises.push(compactIDB.readData('credentials', indexArr[i]))
-                            Promise.all(promises).then(shares => {
-                                var secret = floCrypto.retrieveShamirSecret(shares)
-                                if (secret)
-                                    resolve(secret)
-                                else
-                                    reject("Shares are insufficient or incorrect")
-                            }).catch(error => reject(error))
-                        })
-                    }
-
-                    const writeSharesToIDB = function (shares, i = 0, resultIndexes = []) {
-                        return new Promise((resolve, reject) => {
-                            if (i >= shares.length)
-                                return resolve(resultIndexes)
-                            var n = floCrypto.randInt(0, 100000)
-                            compactIDB.addData("credentials", shares[i], n).then(res => {
-                                resultIndexes.push(n)
-                                writeSharesToIDB(shares, i + 1, resultIndexes)
-                                    .then(result => resolve(result))
-                            }).catch(error => {
-                                writeSharesToIDB(shares, i, resultIndexes)
-                                    .then(result => resolve(result))
-                            })
-                        })
-                    }
-
-                    const getPrivateKeyCredentials = function () {
-                        return new Promise((resolve, reject) => {
-                            var indexArr = localStorage.getItem(`${floGlobals.application}#privKey`)
-                            if (indexArr) {
-                                readSharesFromIDB(JSON.parse(indexArr))
-                                    .then(result => resolve(result))
-                                    .catch(error => reject(error))
-                            } else {
-                                var privKey;
-                                inputFn("PRIVATE_KEY").then(result => {
-                                    try {
-                                        if (!result)
-                                            return reject("Empty Private Key")
-                                        var floID = floCrypto.getFloIDfromPubkeyHex(
-                                            floCrypto.getPubKeyHex(result))
-                                        privKey = result
-                                    } catch (error) {
-                                        console.error(error)
-                                        return reject("Invalid Private Key")
-                                    }
-                                }).catch(error => {
-                                    console.log(error, "Generating Random Keys")
-                                    privKey = floCrypto.generateNewID().privKey
-                                }).finally(_ => {
-                                    var threshold = floCrypto.randInt(10, 20)
-                                    writeSharesToIDB(floCrypto.createShamirsSecretShares(
-                                        privKey, threshold, threshold)).then(
-                                        resultIndexes => {
-                                            //store index keys in localStorage
-                                            localStorage.setItem(
-                                                `${floGlobals.application}#privKey`,
-                                                JSON.stringify(resultIndexes))
-                                            //also add a dummy privatekey to the IDB
-                                            var randomPrivKey = floCrypto
-                                                .generateNewID().privKey
-                                            var randomThreshold = floCrypto.randInt(10,
-                                                20)
-                                            writeSharesToIDB(floCrypto
-                                                .createShamirsSecretShares(
-                                                    randomPrivKey, randomThreshold,
-                                                    randomThreshold))
-                                            //resolve private Key
-                                            resolve(privKey)
-                                        }).catch(error => reject(error))
-                                })
-                            }
-                        })
-                    }
-
-                    const checkIfPinRequired = function (key) {
-                        return new Promise((resolve, reject) => {
-                            if (key.length == 52)
-                                resolve(key)
-                            else {
-                                inputFn("PIN/Password").then(pwd => {
-                                    try {
-                                        let privKey = Crypto.AES.decrypt(key, pwd);
-                                        resolve(privKey)
-                                    } catch (error) {
-                                        reject("Access Denied: Incorrect PIN/Password")
-                                    }
-                                }).catch(error => reject(
-                                    "Access Denied: PIN/Password required"))
-                            }
-                        })
-                    }
-
-                    return new Promise((resolve, reject) => {
-                        getPrivateKeyCredentials().then(key => {
-                            checkIfPinRequired(key).then(privKey => {
-                                try {
-                                    myPrivKey = privKey
-                                    myPubKey = floCrypto.getPubKeyHex(myPrivKey)
-                                    myFloID = floCrypto.getFloIDfromPubkeyHex(myPubKey)
-                                    resolve('Login Credentials loaded successful')
-                                } catch (error) {
-                                    reject("Corrupted Private Key")
-                                }
-                            }).catch(error => reject(error))
+                            resolve("Loaded Data from app IDB")
                         }).catch(error => reject(error))
                     })
                 }
             },
 
-            callStartUpFunction: function (fname) {
-                return new Promise((resolve, reject) => {
-                    this.startUpFunctions[fname]().then(result => {
-                        this.callStartUpFunction.completed += 1
-                        reactor.dispatchEvent("startUpSuccessLog",
-                            `${result}\nCompleted ${this.callStartUpFunction.completed}/${this.callStartUpFunction.total} Startup functions`
-                        )
-                        resolve(true)
-                    }).catch(error => {
-                        this.callStartUpFunction.failed += 1
-                        reactor.dispatchEvent("startUpErrorLog",
-                            `${error}\nFailed ${this.callStartUpFunction.failed}/${this.callStartUpFunction.total} Startup functions`
-                        )
-                        reject(false)
+            getCredentials: function() {
+
+                const defaultInput = function(type) {
+                    return new Promise((resolve, reject) => {
+                        let inputVal = prompt(`Enter ${type}: `)
+                        if (inputVal === null)
+                            reject(null)
+                        else
+                            resolve(inputVal)
                     })
+                }
+
+                const inputFn = this.getCredentials.privKeyInput || defaultInput;
+
+                const readSharesFromIDB = function(indexArr) {
+                    return new Promise((resolve, reject) => {
+                        var promises = []
+                        for (var i = 0; i < indexArr.length; i++)
+                            promises.push(compactIDB.readData('credentials', indexArr[i]))
+                        Promise.all(promises).then(shares => {
+                            var secret = floCrypto.retrieveShamirSecret(shares)
+                            if (secret)
+                                resolve(secret)
+                            else
+                                reject("Shares are insufficient or incorrect")
+                        }).catch(error => reject(error))
+                    })
+                }
+
+                const writeSharesToIDB = function(shares, i = 0, resultIndexes = []) {
+                    return new Promise(resolve => {
+                        if (i >= shares.length)
+                            return resolve(resultIndexes)
+                        var n = floCrypto.randInt(0, 100000)
+                        compactIDB.addData("credentials", shares[i], n).then(res => {
+                            resultIndexes.push(n)
+                            writeSharesToIDB(shares, i + 1, resultIndexes)
+                                .then(result => resolve(result))
+                        }).catch(error => {
+                            writeSharesToIDB(shares, i, resultIndexes)
+                                .then(result => resolve(result))
+                        })
+                    })
+                }
+
+                const getPrivateKeyCredentials = function() {
+                    return new Promise((resolve, reject) => {
+                        var indexArr = localStorage.getItem(`${floGlobals.application}#privKey`)
+                        if (indexArr) {
+                            readSharesFromIDB(JSON.parse(indexArr))
+                                .then(result => resolve(result))
+                                .catch(error => reject(error))
+                        } else {
+                            var privKey;
+                            inputFn("PRIVATE_KEY").then(result => {
+                                if (!result)
+                                    return reject("Empty Private Key")
+                                var floID = floCrypto.getFloID(result)
+                                if (!floID || !floCrypto.validateAddr(floID))
+                                    return reject("Invalid Private Key")
+                                privKey = result;
+                            }).catch(error => {
+                                console.log(error, "Generating Random Keys")
+                                privKey = floCrypto.generateNewID().privKey
+                            }).finally(_ => {
+                                if (!privKey)
+                                    return;
+                                var threshold = floCrypto.randInt(10, 20)
+                                var shares = floCrypto.createShamirsSecretShares(privKey, threshold, threshold)
+                                writeSharesToIDB(shares).then(resultIndexes => {
+                                    //store index keys in localStorage
+                                    localStorage.setItem(`${floGlobals.application}#privKey`, JSON.stringify(resultIndexes))
+                                    //also add a dummy privatekey to the IDB
+                                    var randomPrivKey = floCrypto.generateNewID().privKey
+                                    var randomThreshold = floCrypto.randInt(10, 20)
+                                    var randomShares = floCrypto.createShamirsSecretShares(randomPrivKey, randomThreshold, randomThreshold)
+                                    writeSharesToIDB(randomShares)
+                                    //resolve private Key
+                                    resolve(privKey)
+                                })
+                            })
+                        }
+                    })
+                }
+
+                const checkIfPinRequired = function(key) {
+                    return new Promise((resolve, reject) => {
+                        if (key.length == 52)
+                            resolve(key)
+                        else {
+                            inputFn("PIN/Password").then(pwd => {
+                                try {
+                                    let privKey = Crypto.AES.decrypt(key, pwd);
+                                    resolve(privKey)
+                                } catch (error) {
+                                    reject("Access Denied: Incorrect PIN/Password")
+                                }
+                            }).catch(error => reject("Access Denied: PIN/Password required"))
+                        }
+                    })
+                }
+
+                return new Promise((resolve, reject) => {
+                    getPrivateKeyCredentials().then(key => {
+                        checkIfPinRequired(key).then(privKey => {
+                            try {
+                                myPrivKey = privKey
+                                myPubKey = floCrypto.getPubKeyHex(myPrivKey)
+                                myFloID = floCrypto.getFloID(myPubKey)
+                                resolve('Login Credentials loaded successful')
+                            } catch (error) {
+                                console.log(error)
+                                reject("Corrupted Private Key")
+                            }
+                        }).catch(error => reject(error))
+                    }).catch(error => reject(error))
                 })
             },
 
-            getFilterString: function (type, options = {}) {
-                var filterStr = JSON.stringify({
-                    application: options.application || floGlobals.application,
-                    type: type,
-                    comment: options.comment
+            startUpLog: function(status, log) {
+                if (status)
+                    console.log(log)
+                else
+                    console.error(log)
+            },
+
+            callStartUpFunction: function(fname) {
+                return new Promise((resolve, reject) => {
+                    this.startUpFunctions[fname]().then(result => {
+                        this.callStartUpFunction.completed += 1
+                        this.startUpLog(true, `${result}\nCompleted ${this.callStartUpFunction.completed}/${this.callStartUpFunction.total} Startup functions`)
+                        resolve(true)
+                    }).catch(error => {
+                        this.callStartUpFunction.failed += 1
+                        this.startUpLog(false, `${error}\nFailed ${this.callStartUpFunction.failed}/${this.callStartUpFunction.total} Startup functions`)
+                        reject(false)
+                    })
                 })
-                return filterStr
             }
         },
 
-        launchStartUp: function () {
+        launchStartUp: function() {
             return new Promise((resolve, reject) => {
                 this.util.initIndexedDB().then(log => {
                     console.log(log)
-                    this.util.callStartUpFunction.total = Object.keys(this.util
-                        .startUpFunctions).length
+                    this.util.callStartUpFunction.total = Object.keys(this.util.startUpFunctions).length
                     this.util.callStartUpFunction.completed = 0
                     this.util.callStartUpFunction.failed = 0
-                    var promises = []
+                    var p0 = []
                     for (fn in this.util.startUpFunctions)
-                        promises.push(this.util.callStartUpFunction(fn))
-                    Promise.all(promises)
-                        .then(results => resolve('App Startup finished successful'))
-                        .catch(errors => reject('App StartUp failed'))
-                })
+                        p0.push(this.util.callStartUpFunction(fn))
+                    const CnL = p => new Promise((res, rej) => {
+                        p.then(r => {
+                            this.util.startUpLog(true, r)
+                            res(r)
+                        }).catch(e => {
+                            this.util.startUpLog(false, e)
+                            rej(e)
+                        })
+                    })
+                    const callMidStartup = () => new Promise((res, rej) => {
+                        if (this.launchStartUp.midFunction instanceof Function) {
+                            this.launchStartUp.midFunction()
+                                .then(r => res("Mid startup function completed"))
+                                .catch(e => rej("Mid startup function failed"))
+                        } else
+                            res("No mid startup function")
+                    })
+                    let p1 = new Promise((res, rej) => {
+                        Promise.all(p0).then(r => {
+                            CnL(callMidStartup())
+                                .then(r => res(true))
+                                .catch(e => rej(false))
+                        })
+                    });
+                    let p2 = new Promise((res, rej) => {
+                        CnL(this.util.getCredentials()).then(r => {
+                            CnL(this.util.initUserDB(myFloID)).then(r => {
+                                CnL(this.util.loadUserDB(myFloID))
+                                    .then(r => res(true))
+                                    .catch(e => rej(false))
+                            }).catch(e => rej(false))
+                        }).catch(e => rej(false))
+                    })
+                    Promise.all([p1, p2])
+                        .then(r => resolve('App Startup finished successful'))
+                        .catch(e => reject('App Startup failed'))
+                }).catch(error => reject("App database initiation failed"))
             })
         },
 
-        addStartUpFunction: function (fname, fn) {
+        addStartUpFunction: function(fname, fn) {
             if (fname in this.util.startUpFunctions)
                 throw (`Function ${fname} already defined`)
             this.util.startUpFunctions[fname] = fn;
         },
 
-        setCustomPrivKeyInput: function (customFn) {
-            this.util.startUpFunctions.getCredentials.privKeyInput = customFn
+        setMidStartup: function(fn) {
+            if (fn instanceof Function)
+                this.launchStartUp.midFunction = fn;
         },
 
-        setAppObjectStores: function (appObs) {
-            this.util.appObs = appObs
+        setCustomStartupLogger: function(logger) {
+            this.util.startUpLog = logger;
         },
 
-        manageSubAdmins(adminPrivKey, addList, rmList) {
+        setCustomPrivKeyInput: function(customFn) {
+            this.util.getCredentials.privKeyInput = customFn
+        },
+
+        setAppObjectStores: function(appObs) {
+            this.util.initIndexedDB.appObs = appObs
+        },
+
+        storeContact(floID, name) {
+            return new Promise((resolve, reject) => {
+                if (!floCrypto.validateAddr(floID))
+                    return reject("Invalid floID!")
+                compactIDB.writeData("contacts", name, floID, `floDapps#${myFloID}`).then(result => {
+                    floGlobals.contacts[floID] = name;
+                    resolve("Contact stored")
+                }).catch(error => reject(error))
+            });
+        },
+
+        storePubKey(floID, pubKey) {
+            return new Promise((resolve, reject) => {
+                if (floID in floGlobals.pubKeys)
+                    return resolve("pubKey already stored")
+                if (!floCrypto.validateAddr(floID))
+                    return reject("Invalid floID!")
+                if (floCrypto.getFloID(pubKey) != floID)
+                    return reject("Incorrect pubKey")
+                compactIDB.writeData("pubKeys", pubKey, floID, `floDapps#${myFloID}`).then(result => {
+                    floGlobals.pubKeys[floID] = pubKey;
+                    resolve("pubKey stored")
+                }).catch(error => reject(error))
+            });
+        },
+
+        sendMessage(floID, message) {
+            return new Promise((resolve, reject) => {
+                let options = {
+                    receiverID: floID,
+                    application: "floDapps",
+                    comment: floGlobals.application
+                }
+                if (floID in floGlobals.pubKeys)
+                    message = floCrypto.encryptData(JSON.stringify(message), floGlobals.pubKeys[floID])
+                floCloudAPI.sendApplicationData(message, "Message", options)
+                    .then(result => resolve(result))
+                    .catch(error => reject(error))
+            })
+        },
+
+        requestInbox(callback) {
+            return new Promise((resolve, reject) => {
+                let lastVC = Object.keys(floGlobals.messages).sort().pop()
+                let options = {
+                    receiverID: myFloID,
+                    application: "floDapps",
+                    lowerVectorClock: lastVC + 1
+                }
+                options.callback = (d, e) => {
+                    for (let v in d) {
+                        try {
+                            if (d[v].message instanceof Object && "secret" in d[v].message)
+                                d[v].message = floCrypto.decryptData(d[v].message, myPrivKey)
+                        } catch (error) {}
+                        compactIDB.writeData("messages", d[v], v, `floDapps#${myFloID}`)
+                        floGlobals.messages[v] = d[v]
+                    }
+                    if (callback instanceof Function)
+                        callback(d, e)
+                }
+                floCloudAPI.requestApplicationData("Message", options)
+                    .then(result => resolve(result))
+                    .catch(error => reject(error))
+            })
+        },
+
+        manageAppConfig(adminPrivKey, addList, rmList, settings) {
             return new Promise((resolve, reject) => {
                 if (!Array.isArray(addList) || !addList.length) addList = undefined;
                 if (!Array.isArray(rmList) || !rmList.length) rmList = undefined;
-                if (!addList && !rmList)
-                    return reject("subAdmin manage list is empty")
+                if (!settings || typeof settings !== "object" || !Object.keys(settings).length) settings = undefined;
+                if (!addList && !rmList && !settings)
+                    return reject("No configuration change")
                 var floData = {
                     [floGlobals.application]: {
                         addSubAdmin: addList,
                         removeSubAdmin: rmList,
-                    }
-                }
-                var floID = floCrypto.getFloIDfromPubkeyHex(floCrypto.getPubKeyHex(adminPrivKey))
-                if (floID != floGlobals.adminID)
-                    reject('Access Denied for Admin privilege')
-                else
-                    floBlockchainAPI.writeData(floID, JSON.stringify(floData), adminPrivKey)
-                    .then(result => resolve(['Updated SubAdmin List', result]))
-                    .catch(error => reject(error))
-            })
-        },
-
-        setApplicationSettings(adminPrivKey, settings = {}) {
-            return new Promise((resolve, reject) => {
-                if (!settings || typeof settings !== "object")
-                    return reject("Settings must be object")
-                var floData = {
-                    [floGlobals.application]: {
                         settings: settings
                     }
                 }
-                var floID = floCrypto.getFloIDfromPubkeyHex(floCrypto.getPubKeyHex(adminPrivKey))
+                var floID = floCrypto.getFloID(adminPrivKey)
                 if (floID != floGlobals.adminID)
                     reject('Access Denied for Admin privilege')
                 else
                     floBlockchainAPI.writeData(floID, JSON.stringify(floData), adminPrivKey)
-                    .then(result => resolve(['Updated app settings', result]))
+                    .then(result => resolve(['Updated App Configuration', result]))
                     .catch(error => reject(error))
             })
         },
 
-        clearCredentials: function () {
+        clearCredentials: function() {
             return new Promise((resolve, reject) => {
-                compactIDB.clearData('credentials').then(result => {
+                compactIDB.clearData('credentials', floGlobals.application).then(result => {
                     localStorage.removeItem(`${floGlobals.application}#privKey`)
                     myPrivKey = myPubKey = myFloID = undefined;
                     resolve("privKey credentials deleted!")
@@ -9145,7 +9167,31 @@ Bitcoin.Util = {
             })
         },
 
-        securePrivKey: function (pwd) {
+        deleteUserData: function(credentials = false) {
+            return new Promise((resolve, reject) => {
+                let p = []
+                p.push(compactIDB.deleteDB(`floDapps#${myFloID}`))
+                if (credentials)
+                    p.push(this.clearCredentials())
+                Promise.all(p)
+                    .then(result => resolve('User database(local) deleted'))
+                    .catch(error => reject(error))
+            })
+        },
+
+        deleteAppData: function() {
+            return new Promise((resolve, reject) => {
+                compactIDB.deleteDB(floGlobals.application).then(result => {
+                    localStorage.removeItem(`${floGlobals.application}#privKey`)
+                    myPrivKey = myPubKey = myFloID = undefined;
+                    compactIDB.removeData('lastTx', `${floGlobals.application}|${floGlobals.adminID}`, 'floDapps')
+                        .then(result => resolve("App database(local) deleted"))
+                        .catch(error => reject(error))
+                }).catch(error => reject(error))
+            })
+        },
+
+        securePrivKey: function(pwd) {
             return new Promise((resolve, reject) => {
                 let indexArr = localStorage.getItem(`${floGlobals.application}#privKey`)
                 if (!indexArr)
@@ -9155,39 +9201,40 @@ Bitcoin.Util = {
                 let threshold = indexArr.length;
                 let shares = floCrypto.createShamirsSecretShares(encryptedKey, threshold, threshold)
                 let promises = [];
+                let overwriteFn = (share, index) =>
+                    compactIDB.writeData("credentials", share, index, floGlobals.application);
                 for (var i = 0; i < threshold; i++)
-                    promises.push(compactIDB.writeData("credentials", shares[i], indexArr[i], floGlobals
-                        .application));
+                    promises.push(overwriteFn(shares[i], indexArr[i]));
                 Promise.all(promises)
                     .then(results => resolve("Private Key Secured"))
                     .catch(error => reject(error))
             })
         },
 
-        objectDataMapper: function (object, path, data) {
-            var resObject = JSON.parse(JSON.stringify(object))
-            var pos = resObject;
-            path.forEach(p => pos = pos[p])
-            if (Array.isArray(pos)) {
-                pos.push(data)
-                return resObject
-            } else
-                throw ('Path is not an Array')
-        },
-
-        getNextGeneralData: function (type, vectorClock, options = {}) {
-            var filter = this.util.getFilterString(type, options)
-            var filteredResult = []
-            for (var i = 0; i < floGlobals.generalData[filter].length; i++)
-                if (floGlobals.generalData[filter][i].vectorClock > vectorClock)
-                    filteredResult.push(JSON.parse(JSON.stringify(floGlobals.generalData[filter][i])))
+        getNextGeneralData: function(type, vectorClock = null, options = {}) {
+            var fk = floCloudAPI.util.filterKey(type, options)
+            vectorClock = vectorClock || this.getNextGeneralData[fk] || '0';
+            var filteredResult = {}
+            if (floGlobals.generalData[fk]) {
+                for (let d in floGlobals.generalData[fk])
+                    if (d > vectorClock)
+                        filteredResult[d] = JSON.parse(JSON.stringify(floGlobals.generalData[fk][d]))
+            } else if (options.comment) {
+                let comment = options.comment;
+                delete options.comment;
+                let fk = floCloudAPI.util.filterKey(type, options);
+                for (let d in floGlobals.generalData[fk])
+                    if (d > vectorClock && floGlobals.generalData[fk][d].comment == comment)
+                        filteredResult[d] = JSON.parse(JSON.stringify(floGlobals.generalData[fk][d]))
+            }
             if (options.decrypt) {
                 let decryptionKey = (options.decrypt === true) ? myPrivKey : options.decrypt;
                 if (!Array.isArray(decryptionKey))
                     decryptionKey = [decryptionKey];
-                filteredResult.forEach(data => {
+                for (let f in filteredResult) {
+                    let data = filteredResult[f]
                     try {
-                        if ("secret" in data.message && "senderPublicKeyString" in data.message) {
+                        if (data.message instanceof Object && "secret" in data.message) {
                             for (let key of decryptionKey) {
                                 try {
                                     let tmp = floCrypto.decryptData(data.message, key)
@@ -9197,17 +9244,58 @@ Bitcoin.Util = {
                             }
                         }
                     } catch (error) {}
+                }
+            }
+            this.getNextGeneralData[fk] = Object.keys(filteredResult).sort().pop();
+            return filteredResult;
+        },
+
+        syncData: {
+            oldDevice: function() {
+                return new Promise((resolve, reject) => {
+                    let sync = {
+                        contacts: floGlobals.contacts,
+                        pubKeys: floGlobals.pubKeys,
+                        messages: floGlobals.messages
+                    }
+                    let message = Crypto.AES.encrypt(JSON.stringify(sync), myPrivKey)
+                    let options = {
+                        receiverID: myFloID,
+                        application: "floDapps"
+                    }
+                    floCloudAPI.sendApplicationData(message, "syncData", options)
+                        .then(result => resolve(result))
+                        .catch(error => reject(error))
+                })
+            },
+
+            newDevice() {
+                return new Promise((resolve, reject) => {
+                    var options = {
+                        receiverID: myFloID,
+                        senderIDs: myFloID,
+                        application: "floDapps",
+                        mostRecent: true,
+                    }
+                    floCloudAPI.requestApplicationData("syncData", options).then(response => {
+                        let vc = Object.keys(response).sort().pop()
+                        let sync = JSON.parse(Crypto.AES.decrypt(response[vc].message, myPrivKey))
+                        let promises = []
+                        let store = (key, val, obs) => promises.push(compactIDB.writeData(obs, val, key, `floDapps#${floID}`));
+                        ["contacts", "pubKeys", "messages"].forEach(c => {
+                            for (let i in sync[c]) {
+                                store(i, sync[c][i], c)
+                                floGlobals[c][i] = sync[c][i]
+                            }
+                        })
+                        Promise.all(promises)
+                            .then(results => resolve("Sync data successful"))
+                            .catch(error => reject(error))
+                    }).catch(error => reject(error))
                 })
             }
-            return filteredResult
         }
     }
-
-    reactor.registerEvent("startUpSuccessLog");
-    reactor.addEventListener("startUpSuccessLog", log => console.log(log))
-
-    reactor.registerEvent("startUpErrorLog");
-    reactor.addEventListener("startUpErrorLog", log => console.error(log))
 </script>
 
 <script id="onLoadStartUp">