diff --git a/floBank.html b/floBank.html
index ff8afbf..a76cba5 100644
--- a/floBank.html
+++ b/floBank.html
@@ -2,48 +2,72 @@
 <html>
 
 <head>
-  <title>FLO Standard Operators</title>
+  <title>FLO Bank</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://livenet.flocha.in/'],
+            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
+        application: "test_bank",
+    }
 </script>
+<script id="onLoadStartUp">
+    function onLoadStartUp() {
 
+        //floDapps.addStartUpFunction('Sample', Promised Function)
+        //floDapps.setAppObjectStores({sampleObs1:{}, sampleObs2:{options{autoIncrement:true, keyPath:'SampleKey'}, Indexes:{sampleIndex:{}}}})
+        //floDapps.setCustomPrivKeyInput( () => { FUNCTION BODY *must resolve private key* } )
+
+        floDapps.setAppObjectStores({
+            accounts: {},
+            responses: {},
+            requests: {},
+            settings: {},
+            appendix: {}
+        });
+        delete floDapps.util.startUpFunctions.readAppConfigFromAPI;
+        delete floDapps.util.startUpFunctions.loadDataFromAppIDB;
+        floDapps.launchStartUp().then(result => {
+            console.log(result);
+            alert(`Welcome FLO_ID: ${myFloID}`);
+            //App functions....
+            bank_app.launchApp(DummyCallBack, DummyCallBack)
+                .then(result => console.log(result))
+                .catch(error => console.error(error))
+        }).catch(error => console.error(error));
+    }
+
+    const DummyCallBack = (d, e) => {
+        if (e) console.error("DummyCallback", e);
+        console.log("DummyCallback", d);
+    }
+</script>
 </head>
 
 <body onload="onLoadStartUp()">
     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 +4958,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 +6765,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 +6790,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 +6802,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 +6824,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 +6916,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 +6935,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 +6942,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.1">
     /* FLO Crypto Operators*/
     const floCrypto = {
 
@@ -7028,17 +6978,19 @@ Bitcoin.Util = {
 
             ecparams: EllipticCurve.getSECCurveByName("secp256k1"),
 
-            exponent1: function () {
+            asciiAlternatives: `‘ '\n’ '\n“ "\n” "\n– --\n— ---\n≥ >=\n≤ <=\n≠ !=\n× *\n÷ /\n← <-\n→ ->\n↔ <->\n⇒ =>\n⇐ <=\n⇔ <=>`,
+
+            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);
@@ -7053,16 +7005,15 @@ Bitcoin.Util = {
                 // verify y value
                 let resultBigInt = y.mod(BigInteger("2"));
                 let check = resultBigInt.toString() % 2;
-                if (prefix_modulus !== check) {
+                if (prefix_modulus !== check)
                     yDecimalValue = y.negate().mod(p).toString();
-                }
                 return {
                     x: xDecimalValue,
                     y: yDecimalValue
                 };
             },
 
-            getSenderPublicKeyString: function () {
+            getSenderPublicKeyString: function() {
                 privateKey = ellipticCurveEncryption.senderRandom();
                 senderPublicKeyString = ellipticCurveEncryption.senderPublicString(privateKey);
                 return {
@@ -7071,39 +7022,28 @@ Bitcoin.Util = {
                 }
             },
 
-            deriveSharedKeySender: function (receiverCompressedPublicKey, senderPrivateKey) {
-                try {
-                    let receiverPublicKeyString = this.getUncompressedPublicKey(receiverCompressedPublicKey);
-                    var senderDerivedKey = ellipticCurveEncryption.senderSharedKeyDerivation(
-                        receiverPublicKeyString.x, receiverPublicKeyString.y, senderPrivateKey);
-                    return senderDerivedKey;
-                } catch (error) {
-                    return new Error(error);
-                }
+            deriveSharedKeySender: function(receiverCompressedPublicKey, senderPrivateKey) {
+                let receiverPublicKeyString = this.getUncompressedPublicKey(receiverCompressedPublicKey);
+                var senderDerivedKey = ellipticCurveEncryption.senderSharedKeyDerivation(
+                    receiverPublicKeyString.x, receiverPublicKeyString.y, senderPrivateKey);
+                return senderDerivedKey;
             },
 
-            deriveReceiverSharedKey: function (senderPublicKeyString, receiverPrivateKey) {
+            deriveReceiverSharedKey: function(senderPublicKeyString, receiverPrivateKey) {
                 return ellipticCurveEncryption.receiverSharedKeyDerivation(
-                    senderPublicKeyString.XValuePublicString, senderPublicKeyString.YValuePublicString,
-                    receiverPrivateKey);
+                    senderPublicKeyString.XValuePublicString, senderPublicKeyString.YValuePublicString, receiverPrivateKey);
             },
 
-            getReceiverPublicKeyString: function (privateKey) {
+            getReceiverPublicKeyString: function(privateKey) {
                 return ellipticCurveEncryption.receiverPublicString(privateKey);
             },
 
-            deriveSharedKeyReceiver: function (senderPublicKeyString, receiverPrivateKey) {
-                try {
-                    return ellipticCurveEncryption.receiverSharedKeyDerivation(senderPublicKeyString
-                        .XValuePublicString,
-                        senderPublicKeyString.YValuePublicString, receiverPrivateKey);
-
-                } catch (error) {
-                    return new Error(error);
-                }
+            deriveSharedKeyReceiver: function(senderPublicKeyString, receiverPrivateKey) {
+                return ellipticCurveEncryption.receiverSharedKeyDerivation(
+                    senderPublicKeyString.XValuePublicString, senderPublicKeyString.YValuePublicString, receiverPrivateKey);
             },
 
-            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 +7060,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 +7080,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 +7093,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 +7112,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 +7128,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 +7143,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 +7158,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 +7203,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 +7215,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 +7229,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));
@@ -7299,50 +7245,114 @@ Bitcoin.Util = {
             } catch {
                 return false;
             }
+        },
+
+        validateASCII: function(string, bool = true) {
+            if (typeof string !== "string")
+                return null;
+            if (bool) {
+                let x;
+                for (let i = 0; i < string.length; i++) {
+                    x = string.charCodeAt(i);
+                    if (x < 32 || x > 127)
+                        return false;
+                }
+                return true;
+            } else {
+                let x, invalids = {};
+                for (let i = 0; i < string.length; i++) {
+                    x = string.charCodeAt(i);
+                    if (x < 32 || x > 127)
+                        if (x in invalids)
+                            invalids[string[i]].push(i)
+                    else
+                        invalids[string[i]] = [i];
+                }
+                if (Object.keys(invalids).length)
+                    return invalids;
+                else
+                    return true;
+            }
+        },
+
+        convertToASCII: function(string, mode = 'soft-remove') {
+            let chars = this.validateASCII(string, false);
+            if (chars === true)
+                return string;
+            else if (chars === null)
+                return null;
+            let convertor, result = string,
+                refAlt = {};
+            this.util.asciiAlternatives.split('\n').forEach(a => refAlt[a[0]] = a.slice(2));
+            mode = mode.toLowerCase();
+            if (mode === "hard-unicode")
+                convertor = (c) => `\\u${('000'+c.charCodeAt().toString(16)).slice(-4)}`;
+            else if (mode === "soft-unicode")
+                convertor = (c) => refAlt[c] || `\\u${('000'+c.charCodeAt().toString(16)).slice(-4)}`;
+            else if (mode === "hard-remove")
+                convertor = c => "";
+            else if (mode === "soft-remove")
+                convertor = c => refAlt[c] || "";
+            else
+                return null;
+            for (let c in chars)
+                result = result.replaceAll(c, convertor(c));
+            return result;
+        },
+
+        revertUnicode: function(string) {
+            return string.replace(/\\u[\dA-F]{4}/gi,
+                m => String.fromCharCode(parseInt(m.replace(/\\u/g, ''), 16)));
         }
     }
 </script>
-<script id="floBlockchainAPI">
+<script id="floBlockchainAPI" version="2.0.1e">
     /* 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) {
+            curPos: floCrypto.randInt(0, floGlobals.apiURL[floGlobals.blockchain].length - 1),
+            fetch_retry: function(apicall, rm_flosight) {
                 return new Promise((resolve, reject) => {
-                    this.serverList.splice(this.curPos, 1);
-                    this.curPos = floCrypto.randInt(0, this.serverList.length)
+                    let i = this.serverList.indexOf(rm_flosight)
+                    if (i != -1) this.serverList.splice(i, 1);
+                    this.curPos = floCrypto.randInt(0, this.serverList.length - 1)
                     this.fetch_api(apicall)
                         .then(result => resolve(result))
                         .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")
                     else {
-                        fetch(this.serverList[this.curPos] + apicall).then(response => {
+                        let flosight = this.serverList[this.curPos];
+                        fetch(flosight + apicall).then(response => {
                             if (response.ok)
                                 response.json().then(data => resolve(data));
                             else {
-                                this.fetch_retry(apicall)
+                                this.fetch_retry(apicall, flosight)
                                     .then(result => resolve(result))
                                     .catch(error => reject(error));
                             }
                         }).catch(error => {
-                            this.fetch_retry(apicall)
+                            this.fetch_retry(apicall, flosight)
                                 .then(result => resolve(result))
                                 .catch(error => reject(error));
                         })
                     }
                 })
+            },
+
+            current: function() {
+                return this.serverList[this.curPos];
             }
         },
 
         //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 +7362,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 +7371,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,8 +7382,10 @@ 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.validateASCII(floData))
+                    return reject("Invalid FLO_Data: only printable ASCII characters are allowed");
                 if (!floCrypto.validateAddr(senderAddr))
                     reject(`Invalid address : ${senderAddr}`);
                 else if (!floCrypto.validateAddr(receiverAddr))
@@ -7402,7 +7414,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,12 +7426,14 @@ 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`);
                 if (!floCrypto.verifyPrivKey(privKey, floID))
                     return reject("Invalid Private Key")
+                if (!floCrypto.validateASCII(floData))
+                    return reject("Invalid FLO_Data: only printable ASCII characters are allowed");
 
                 var trx = bitjs.transaction();
                 var utxoAmt = 0.0;
@@ -7433,7 +7447,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 +7463,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 +7495,60 @@ 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; 
+                if (!floCrypto.validateASCII(floData))
+                    return reject("Invalid FLO_Data: only printable ASCII characters are allowed");
+                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 +7570,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 +7585,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 +7617,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 +7641,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 +7654,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 +7666,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 +7678,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 +7696,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`)
@@ -7680,13 +7711,18 @@ Bitcoin.Util = {
         limit       : maximum number of filtered data (default = 1000, negative  = no limit)
         ignoreOld   : ignore old txs (default = 0)
         sentOnly    : filters only sent data
-        pattern     : filters data that starts with a pattern
-        contains    : filters data that contains a string
+        receivedOnly: filters only received data
+        pattern     : filters data that with JSON pattern
         filter      : custom filter funtion for floData (eg . filter: d => {return d[0] == '$'})
+        txid        : (boolean) resolve txid or not
+        sender      : flo-id(s) of sender
+        receiver    : flo-id(s) of receiver
         */
-        readData: function (addr, options = {}) {
-            options.limit = options.limit | 1000
-            options.ignoreOld = options.ignoreOld | 0
+        readData: function(addr, options = {}) {
+            options.limit = options.limit || 0
+            options.ignoreOld = options.ignoreOld || 0
+            if (typeof options.sender === "string") options.sender = [options.sender];
+            if (typeof options.receiver === "string") options.receiver = [options.receiver];
             return new Promise((resolve, reject) => {
                 this.promisedAPI(`api/addrs/${addr}/txs?from=0&to=1`).then(response => {
                     var newItems = response.totalItems - options.ignoreOld;
@@ -7697,20 +7733,54 @@ Bitcoin.Util = {
                             var filteredData = [];
                             for (i = 0; i < (response.totalItems - options.ignoreOld) &&
                                 filteredData.length < options.limit; i++) {
-                                if (options.sentOnly && response.items[i].vin[0].addr !==
-                                    addr)
+                                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.sentOnly) {
+                                    let flag = false;
+                                    for (let vin of response.items[i].vin)
+                                        if (vin.addr === addr) {
+                                            flag = true;
+                                            break;
+                                        }
+                                    if (!flag) continue;
+                                }
+                                if (Array.isArray(options.sender)) {
+                                    let flag = false;
+                                    for (let vin of response.items[i].vin)
+                                        if (options.sender.includes(vin.addr)) {
+                                            flag = true;
+                                            break;
+                                        }
+                                    if (!flag) continue;
+                                }
+                                if (options.receivedOnly) {
+                                    let flag = false;
+                                    for (let vout of response.items[i].vout)
+                                        if (vout.scriptPubKey.addresses[0] === addr) {
+                                            flag = true;
+                                            break;
+                                        }
+                                    if (!flag) continue;
+                                }
+                                if (Array.isArray(options.receiver)) {
+                                    let flag = false;
+                                    for (let vout of response.items[i].vout)
+                                        if (options.receiver.includes(vout.scriptPubKey.addresses[0])) {
+                                            flag = true;
+                                            break;
+                                        }
+                                    if (!flag) continue;
+                                }
+                                if (options.filter && !options.filter(response.items[i].floData))
                                     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.filter && !options.filter(response.items[i]
-                                        .floData))
-                                    continue;
-                                filteredData.push(response.items[i].floData);
+                                filteredData.push(options.txid ? [response.items[i].txid, response.items[i].floData] : response.items[i].floData);
                             }
                             resolve({
                                 totalTxs: response.totalItems,
@@ -7726,644 +7796,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 +7808,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 +7897,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 +7920,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 +7934,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 +7948,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 +7960,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 +7974,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 +7996,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,223 +8032,827 @@ Bitcoin.Util = {
         }
     }
 </script>
-<script id="floCloudAPI">
+<script id="floCloudAPI" version="2.1.0">
     /* 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)
-                        }
-                        floGlobals.vectorClock[message.object] = vc
-                        compactIDB.writeData("vectorClock", vc, message.object)
+            inactive: new Set(),
+
+            ws_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 + "/");
+                    wsConn.onopen = evt => resolve(wsConn);
+                    wsConn.onerror = evt => {
+                        inactive.add(snID)
+                        reject(`${snID} is unavailable`)
                     }
-                } catch (error) {
-                    console.error(error)
-                }
+                })
             },
 
-            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
+            ws_activeConnect(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.ws_connect(snID)
+                        .then(node => resolve(node))
+                        .catch(error => {
+                            if (reverse)
+                                var nxtNode = this.kBucket.prevNode(snID);
+                            else
+                                var nxtNode = this.kBucket.nextNode(snID);
+                            this.ws_activeConnect(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)
+                })
+            },
+
+            fetch_API: function(snID, data) {
+                return new Promise((resolve, reject) => {
+                    if (this.inactive.has(snID))
+                        return reject(`${snID} is not active`);
+                    let fetcher, sn_url = "https://" + floGlobals.supernodes[snID].uri;
+                    if (typeof data === "string")
+                        fetcher = fetch(sn_url + "?" + data);
+                    else if (typeof data === "object" && data.method === "POST")
+                        fetcher = fetch(sn_url, data);
+                    fetcher.then(response => {
+                        if (response.ok)
+                            resolve(response);
+                        else
+                            reject(response);
+                    }).catch(error => reject(error))
+                })
+            },
+
+            fetch_ActiveAPI: function(snID, data, 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.fetch_API(snID, data)
+                        .then(result => resolve(result))
+                        .catch(error => {
+                            this.inactive.add(snID)
+                            if (reverse)
+                                var nxtNode = this.kBucket.prevNode(snID);
+                            else
+                                var nxtNode = this.kBucket.nextNode(snID);
+                            this.fetch_ActiveAPI(nxtNode, data, reverse)
+                                .then(result => resolve(result))
+                                .catch(error => reject(error));
+                        })
+                })
+            },
+
+            singleRequest: function(floID, data_obj, method = "POST") {
+                return new Promise((resolve, reject) => {
+                    let data;
+                    if (method === "POST")
+                        data = {
+                            method: "POST",
+                            body: JSON.stringify(data_obj)
+                        };
+                    else
+                        data = new URLSearchParams(JSON.parse(JSON.stringify(data_obj))).toString();
+                    this.fetch_ActiveAPI(floID, data).then(response => {
+                        response.json()
+                            .then(result => resolve(this.objectifier(result)))
+                            .catch(error => {
+                                response.text()
+                                    .then(result => reject(result)) //Error Message from Node
+                                    .catch(error => reject(error))
+                            })
+                    }).catch(error => reject(error))
+                })
+            },
+
+            liveRequest: function(floID, request, callback) {
+                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.ws_activeConnect(floID).then(node => {
+                        let randID = floCrypto.randString(5);
+                        node.send(JSON.stringify(request));
+                        node.onmessage = (evt) => {
+                            let d = e = null;
+                            try {
+                                let data = this.objectifier(JSON.parse(evt.data)),
+                                    filter = {};
+                                for (let v in data)
+                                    if (checkFilter(v, data[v], request))
+                                        filter[v] = data[v];
+                                d = filter;
+                            } catch (error) {
+                                e = evt.data
+                            } 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)
+                }
+            },
+
+            objectifier: function(data) {
+                if (!Array.isArray(data))
+                    data = [data];
+                return Object.fromEntries(data.map(d => {
+                    d.message = this.decodeMessage(d.message);
+                    return [d.vectorClock, d];
+                }));
             }
         },
 
         //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)
+                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 => resolve(result))
                     .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))
+
+                if (options.callback instanceof Function) {
+                    this.util.liveRequest(request.receiverID, request, options.callback)
+                        .then(result => resolve(result))
+                        .catch(error => reject(error))
+                } else {
+                    if (options.method === "POST")
+                        request = {
+                            time: Date.now(),
+                            request
+                        };
+                    this.util.singleRequest(request.receiverID, request, options.method || "GET")
+                        .then(data => resolve(data)).catch(error => reject(error))
+                }
+            })
+        },
+
+        //(NEEDS UPDATE) 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))
+            })
+        },
+
+        //(NEEDS UPDATE) 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 +8861,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 +9309,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 +9343,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,738 +9386,1062 @@ Bitcoin.Util = {
                             }
                         }
                     } catch (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">
-    function onLoadStartUp() {
-
-        //floDapps.addStartUpFunction('Sample', Promised Function)
-        //floDapps.setAppObjectStores({sampleObs1:{}, sampleObs2:{options{autoIncrement:true, keyPath:'SampleKey'}, Indexes:{sampleIndex:{}}}})
-        //floDapps.setCustomPrivKeyInput( () => { FUNCTION BODY *must return private key* } )
-
-        floDapps.launchStartUp().then(result => {
-            console.log(result)
-            alert(`Welcome FLO_ID: ${myFloID}`)
-            floBank.refreshAppData()
-                .then(result => console.log(result))
-                .catch(error => console.error(error))
-            //App functions....
-        }).catch(error => console.error(error))
-    }
-</script>
-
-<script id="floBank">
-    const floBank = {
-
-        util: {
-
-            refreshObjectData() {
-                return new Promise((resolve, reject) => {
-                    floCloudAPI.requestObjectData("bank")
-                        .then(results => resolve('Object Data Refreshed Successfully'))
-                        .catch(error => reject(error))
-                })
-            },
-
-            refreshRequests() {
-                return new Promise((resolve, reject) => {
-                    floCloudAPI.requestGeneralData("requests", {
-                            senderIDs: (floGlobals.subAdmins.includes(myFloID) ? undefined : myFloID)
-                        }).then(results => resolve('Requests refreshed Successfully'))
-                        .catch(error => reject(error))
-                })
-            },
-
-            refreshInbox() {
-                return new Promise((resolve, reject) => {
-                    floCloudAPI.requestGeneralData("directMessage", {
-                            receiverID: myFloID,
-                            senderIDs: (floGlobals.subAdmins.includes(myFloID) ? undefined : floGlobals
-                                .subAdmins)
-                        }).then(results => resolve('Inbox Refreshed Successfully'))
-                        .catch(error => reject(error))
-                })
-            },
-
-            parseRequests() {
-                let raw = floDapps.getNextGeneralData("requests", '0');
-                let requests = {};
-                raw.forEach(r => {
-                    requests[r.vectorClock] = {
-                        processID: r.vectorClock,
-                        requestor: r.sender,
-                        pubKey: r.pubKey,
-                        category: r.message.request,
-                        processor: floGlobals.appObjects.bank.process[r.vectorClock] || null,
-                        payMode: r.message.payMode,
-                        amount: r.message.amount,
-                        period: r.message.period,
-                        index: r.message.index,
-                        collateral: r.message.collateral,
-                        collateralType: r.message.collateralType,
-                    }
-                });
-                this.requests = requests;
-            },
-
-            refreshNetUnitValues() {
-                return new Promise((resolve, reject) => {
-
-                    if (typeof this.unitValues !== "object")
-                        this.unitValues = {
-                            deposit: 1
-                        };
-
-                    //fetch API call function
-                    const fetchValue = function (type) {
-                        return new Promise((res, rej) => {
-                            let c = floGlobals.collaterals[c]
-                            fetch(c.url).then(response => {
-                                if (response.ok) {
-                                    response.json().then(data => {
-                                        let value;
-                                        if (!c.path)
-                                            value = data;
-                                        else if (Array.isArray(c.path)) {
-                                            value = data;
-                                            for (p of path)
-                                                value = value[p];
-                                        } else
-                                            value = data[path];
-                                        if (c.multiplier)
-                                            value *= c.multiplier;
-                                        this.unitValues[type] = value;
-                                        resolve({
-                                            [type]: value
-                                        })
-                                    });
-                                } else
-                                    throw Error("Response Not Valid")
-                            }).catch(error => {
-                                this.unitValues[type] = NaN;
-                                resolve({
-                                    [type]: error
-                                })
-                            })
-                        })
-                    }
-
-                    let promises = [];
-                    for (let c in floGlobals.collaterals)
-                        promises.push(fetchValue(c))
-                    Promise.all(promises)
-                        .then(results => resolve(Object.assign({}, ...results)))
-                        .catch(error => reject(error))
-                })
-            },
+            this.getNextGeneralData[fk] = Object.keys(filteredResult).sort().pop();
+            return filteredResult;
         },
 
-        refreshAppData() {
-            return new Promise((resolve, reject) => {
-                Promise.all([this.util.refreshObjectData(), this.util.refreshRequests(), this.util
-                        .refreshInbox(), this.util.refreshNetUnitValues()
-                    ])
-                    .then(results => {
-                        this.util.parseRequests();
-                        resolve(results);
+        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))
+                })
+            }
+        }
+    }
+</script>
+
+<script>
+    /* decimal.js v10.2.1 https://github.com/MikeMcl/decimal.js/LICENCE */!function(n){"use strict";var h,S,e,o,u=9e15,g=1e9,m="0123456789abcdef",t="2.3025850929940456840179914546843642076011014886287729760333279009675726096773524802359972050895982983419677840422862486334095254650828067566662873690987816894829072083255546808437998948262331985283935053089653777326288461633662222876982198867465436674744042432743651550489343149393914796194044002221051017141748003688084012647080685567743216228355220114804663715659121373450747856947683463616792101806445070648000277502684916746550586856935673420670581136429224554405758925724208241314695689016758940256776311356919292033376587141660230105703089634572075440370847469940168269282808481184289314848524948644871927809676271275775397027668605952496716674183485704422507197965004714951050492214776567636938662976979522110718264549734772662425709429322582798502585509785265383207606726317164309505995087807523710333101197857547331541421808427543863591778117054309827482385045648019095610299291824318237525357709750539565187697510374970888692180205189339507238539205144634197265287286965110862571492198849978748873771345686209167058",r="3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989380952572010654858632789",c={precision:20,rounding:4,modulo:1,toExpNeg:-7,toExpPos:21,minE:-u,maxE:u,crypto:!1},N=!0,f="[DecimalError] ",w=f+"Invalid argument: ",s=f+"Precision limit exceeded",a=f+"crypto unavailable",Z=Math.floor,v=Math.pow,l=/^0b([01]+(\.[01]*)?|\.[01]+)(p[+-]?\d+)?$/i,d=/^0x([0-9a-f]+(\.[0-9a-f]*)?|\.[0-9a-f]+)(p[+-]?\d+)?$/i,p=/^0o([0-7]+(\.[0-7]*)?|\.[0-7]+)(p[+-]?\d+)?$/i,b=/^(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i,P=1e7,R=7,E=t.length-1,x=r.length-1,y={name:"[object Decimal]"};function M(n){var e,i,t,r=n.length-1,s="",o=n[0];if(0<r){for(s+=o,e=1;e<r;e++)t=n[e]+"",(i=R-t.length)&&(s+=B(i)),s+=t;o=n[e],(i=R-(t=o+"").length)&&(s+=B(i))}else if(0===o)return"0";for(;o%10==0;)o/=10;return s+o}function q(n,e,i){if(n!==~~n||n<e||i<n)throw Error(w+n)}function O(n,e,i,t){for(var r,s,o=n[0];10<=o;o/=10)--e;return--e<0?(e+=R,r=0):(r=Math.ceil((e+1)/R),e%=R),o=v(10,R-e),s=n[r]%o|0,null==t?e<3?(0==e?s=s/100|0:1==e&&(s=s/10|0),i<4&&99999==s||3<i&&49999==s||5e4==s||0==s):(i<4&&s+1==o||3<i&&s+1==o/2)&&(n[r+1]/o/100|0)==v(10,e-2)-1||(s==o/2||0==s)&&0==(n[r+1]/o/100|0):e<4?(0==e?s=s/1e3|0:1==e?s=s/100|0:2==e&&(s=s/10|0),(t||i<4)&&9999==s||!t&&3<i&&4999==s):((t||i<4)&&s+1==o||!t&&3<i&&s+1==o/2)&&(n[r+1]/o/1e3|0)==v(10,e-3)-1}function D(n,e,i){for(var t,r,s=[0],o=0,u=n.length;o<u;){for(r=s.length;r--;)s[r]*=e;for(s[0]+=m.indexOf(n.charAt(o++)),t=0;t<s.length;t++)s[t]>i-1&&(void 0===s[t+1]&&(s[t+1]=0),s[t+1]+=s[t]/i|0,s[t]%=i)}return s.reverse()}y.absoluteValue=y.abs=function(){var n=new this.constructor(this);return n.s<0&&(n.s=1),_(n)},y.ceil=function(){return _(new this.constructor(this),this.e+1,2)},y.comparedTo=y.cmp=function(n){var e,i,t,r,s=this,o=s.d,u=(n=new s.constructor(n)).d,c=s.s,f=n.s;if(!o||!u)return c&&f?c!==f?c:o===u?0:!o^c<0?1:-1:NaN;if(!o[0]||!u[0])return o[0]?c:u[0]?-f:0;if(c!==f)return c;if(s.e!==n.e)return s.e>n.e^c<0?1:-1;for(e=0,i=(t=o.length)<(r=u.length)?t:r;e<i;++e)if(o[e]!==u[e])return o[e]>u[e]^c<0?1:-1;return t===r?0:r<t^c<0?1:-1},y.cosine=y.cos=function(){var n,e,i=this,t=i.constructor;return i.d?i.d[0]?(n=t.precision,e=t.rounding,t.precision=n+Math.max(i.e,i.sd())+R,t.rounding=1,i=function(n,e){var i,t,r=e.d.length;t=r<32?(i=Math.ceil(r/3),(1/K(4,i)).toString()):(i=16,"2.3283064365386962890625e-10");n.precision+=i,e=G(n,1,e.times(t),new n(1));for(var s=i;s--;){var o=e.times(e);e=o.times(o).minus(o).times(8).plus(1)}return n.precision-=i,e}(t,Q(t,i)),t.precision=n,t.rounding=e,_(2==o||3==o?i.neg():i,n,e,!0)):new t(1):new t(NaN)},y.cubeRoot=y.cbrt=function(){var n,e,i,t,r,s,o,u,c,f,a=this,h=a.constructor;if(!a.isFinite()||a.isZero())return new h(a);for(N=!1,(s=a.s*v(a.s*a,1/3))&&Math.abs(s)!=1/0?t=new h(s.toString()):(i=M(a.d),(s=((n=a.e)-i.length+1)%3)&&(i+=1==s||-2==s?"0":"00"),s=v(i,1/3),n=Z((n+1)/3)-(n%3==(n<0?-1:2)),(t=new h(i=s==1/0?"5e"+n:(i=s.toExponential()).slice(0,i.indexOf("e")+1)+n)).s=a.s),o=(n=h.precision)+3;;)if(f=(c=(u=t).times(u).times(u)).plus(a),t=F(f.plus(a).times(u),f.plus(c),o+2,1),M(u.d).slice(0,o)===(i=M(t.d)).slice(0,o)){if("9999"!=(i=i.slice(o-3,o+1))&&(r||"4999"!=i)){+i&&(+i.slice(1)||"5"!=i.charAt(0))||(_(t,n+1,1),e=!t.times(t).times(t).eq(a));break}if(!r&&(_(u,n+1,0),u.times(u).times(u).eq(a))){t=u;break}o+=4,r=1}return N=!0,_(t,n,h.rounding,e)},y.decimalPlaces=y.dp=function(){var n,e=this.d,i=NaN;if(e){if(i=((n=e.length-1)-Z(this.e/R))*R,n=e[n])for(;n%10==0;n/=10)i--;i<0&&(i=0)}return i},y.dividedBy=y.div=function(n){return F(this,new this.constructor(n))},y.dividedToIntegerBy=y.divToInt=function(n){var e=this.constructor;return _(F(this,new e(n),0,1,1),e.precision,e.rounding)},y.equals=y.eq=function(n){return 0===this.cmp(n)},y.floor=function(){return _(new this.constructor(this),this.e+1,3)},y.greaterThan=y.gt=function(n){return 0<this.cmp(n)},y.greaterThanOrEqualTo=y.gte=function(n){var e=this.cmp(n);return 1==e||0===e},y.hyperbolicCosine=y.cosh=function(){var n,e,i,t,r,s=this,o=s.constructor,u=new o(1);if(!s.isFinite())return new o(s.s?1/0:NaN);if(s.isZero())return u;i=o.precision,t=o.rounding,o.precision=i+Math.max(s.e,s.sd())+4,o.rounding=1,e=(r=s.d.length)<32?(1/K(4,n=Math.ceil(r/3))).toString():(n=16,"2.3283064365386962890625e-10"),s=G(o,1,s.times(e),new o(1),!0);for(var c,f=n,a=new o(8);f--;)c=s.times(s),s=u.minus(c.times(a.minus(c.times(a))));return _(s,o.precision=i,o.rounding=t,!0)},y.hyperbolicSine=y.sinh=function(){var n,e,i,t,r=this,s=r.constructor;if(!r.isFinite()||r.isZero())return new s(r);if(e=s.precision,i=s.rounding,s.precision=e+Math.max(r.e,r.sd())+4,s.rounding=1,(t=r.d.length)<3)r=G(s,2,r,r,!0);else{n=16<(n=1.4*Math.sqrt(t))?16:0|n,r=G(s,2,r=r.times(1/K(5,n)),r,!0);for(var o,u=new s(5),c=new s(16),f=new s(20);n--;)o=r.times(r),r=r.times(u.plus(o.times(c.times(o).plus(f))))}return _(r,s.precision=e,s.rounding=i,!0)},y.hyperbolicTangent=y.tanh=function(){var n,e,i=this,t=i.constructor;return i.isFinite()?i.isZero()?new t(i):(n=t.precision,e=t.rounding,t.precision=n+7,t.rounding=1,F(i.sinh(),i.cosh(),t.precision=n,t.rounding=e)):new t(i.s)},y.inverseCosine=y.acos=function(){var n,e=this,i=e.constructor,t=e.abs().cmp(1),r=i.precision,s=i.rounding;return-1!==t?0===t?e.isNeg()?I(i,r,s):new i(0):new i(NaN):e.isZero()?I(i,r+4,s).times(.5):(i.precision=r+6,i.rounding=1,e=e.asin(),n=I(i,r+4,s).times(.5),i.precision=r,i.rounding=s,n.minus(e))},y.inverseHyperbolicCosine=y.acosh=function(){var n,e,i=this,t=i.constructor;return i.lte(1)?new t(i.eq(1)?0:NaN):i.isFinite()?(n=t.precision,e=t.rounding,t.precision=n+Math.max(Math.abs(i.e),i.sd())+4,t.rounding=1,N=!1,i=i.times(i).minus(1).sqrt().plus(i),N=!0,t.precision=n,t.rounding=e,i.ln()):new t(i)},y.inverseHyperbolicSine=y.asinh=function(){var n,e,i=this,t=i.constructor;return!i.isFinite()||i.isZero()?new t(i):(n=t.precision,e=t.rounding,t.precision=n+2*Math.max(Math.abs(i.e),i.sd())+6,t.rounding=1,N=!1,i=i.times(i).plus(1).sqrt().plus(i),N=!0,t.precision=n,t.rounding=e,i.ln())},y.inverseHyperbolicTangent=y.atanh=function(){var n,e,i,t,r=this,s=r.constructor;return r.isFinite()?0<=r.e?new s(r.abs().eq(1)?r.s/0:r.isZero()?r:NaN):(n=s.precision,e=s.rounding,t=r.sd(),Math.max(t,n)<2*-r.e-1?_(new s(r),n,e,!0):(s.precision=i=t-r.e,r=F(r.plus(1),new s(1).minus(r),i+n,1),s.precision=n+4,s.rounding=1,r=r.ln(),s.precision=n,s.rounding=e,r.times(.5))):new s(NaN)},y.inverseSine=y.asin=function(){var n,e,i,t,r=this,s=r.constructor;return r.isZero()?new s(r):(e=r.abs().cmp(1),i=s.precision,t=s.rounding,-1!==e?0===e?((n=I(s,i+4,t).times(.5)).s=r.s,n):new s(NaN):(s.precision=i+6,s.rounding=1,r=r.div(new s(1).minus(r.times(r)).sqrt().plus(1)).atan(),s.precision=i,s.rounding=t,r.times(2)))},y.inverseTangent=y.atan=function(){var n,e,i,t,r,s,o,u,c,f=this,a=f.constructor,h=a.precision,l=a.rounding;if(f.isFinite()){if(f.isZero())return new a(f);if(f.abs().eq(1)&&h+4<=x)return(o=I(a,h+4,l).times(.25)).s=f.s,o}else{if(!f.s)return new a(NaN);if(h+4<=x)return(o=I(a,h+4,l).times(.5)).s=f.s,o}for(a.precision=u=h+10,a.rounding=1,n=i=Math.min(28,u/R+2|0);n;--n)f=f.div(f.times(f).plus(1).sqrt().plus(1));for(N=!1,e=Math.ceil(u/R),t=1,c=f.times(f),o=new a(f),r=f;-1!==n;)if(r=r.times(c),s=o.minus(r.div(t+=2)),r=r.times(c),void 0!==(o=s.plus(r.div(t+=2))).d[e])for(n=e;o.d[n]===s.d[n]&&n--;);return i&&(o=o.times(2<<i-1)),N=!0,_(o,a.precision=h,a.rounding=l,!0)},y.isFinite=function(){return!!this.d},y.isInteger=y.isInt=function(){return!!this.d&&Z(this.e/R)>this.d.length-2},y.isNaN=function(){return!this.s},y.isNegative=y.isNeg=function(){return this.s<0},y.isPositive=y.isPos=function(){return 0<this.s},y.isZero=function(){return!!this.d&&0===this.d[0]},y.lessThan=y.lt=function(n){return this.cmp(n)<0},y.lessThanOrEqualTo=y.lte=function(n){return this.cmp(n)<1},y.logarithm=y.log=function(n){var e,i,t,r,s,o,u,c,f=this,a=f.constructor,h=a.precision,l=a.rounding;if(null==n)n=new a(10),e=!0;else{if(i=(n=new a(n)).d,n.s<0||!i||!i[0]||n.eq(1))return new a(NaN);e=n.eq(10)}if(i=f.d,f.s<0||!i||!i[0]||f.eq(1))return new a(i&&!i[0]?-1/0:1!=f.s?NaN:i?0:1/0);if(e)if(1<i.length)s=!0;else{for(r=i[0];r%10==0;)r/=10;s=1!==r}if(N=!1,o=W(f,u=h+5),t=e?C(a,u+10):W(n,u),O((c=F(o,t,u,1)).d,r=h,l))do{if(o=W(f,u+=10),t=e?C(a,u+10):W(n,u),c=F(o,t,u,1),!s){+M(c.d).slice(r+1,r+15)+1==1e14&&(c=_(c,h+1,0));break}}while(O(c.d,r+=10,l));return N=!0,_(c,h,l)},y.minus=y.sub=function(n){var e,i,t,r,s,o,u,c,f,a,h,l,d=this,p=d.constructor;if(n=new p(n),!d.d||!n.d)return d.s&&n.s?d.d?n.s=-n.s:n=new p(n.d||d.s!==n.s?d:NaN):n=new p(NaN),n;if(d.s!=n.s)return n.s=-n.s,d.plus(n);if(f=d.d,l=n.d,u=p.precision,c=p.rounding,!f[0]||!l[0]){if(l[0])n.s=-n.s;else{if(!f[0])return new p(3===c?-0:0);n=new p(d)}return N?_(n,u,c):n}if(i=Z(n.e/R),a=Z(d.e/R),f=f.slice(),s=a-i){for(o=(h=s<0)?(e=f,s=-s,l.length):(e=l,i=a,f.length),(t=Math.max(Math.ceil(u/R),o)+2)<s&&(s=t,e.length=1),e.reverse(),t=s;t--;)e.push(0);e.reverse()}else{for((h=(t=f.length)<(o=l.length))&&(o=t),t=0;t<o;t++)if(f[t]!=l[t]){h=f[t]<l[t];break}s=0}for(h&&(e=f,f=l,l=e,n.s=-n.s),o=f.length,t=l.length-o;0<t;--t)f[o++]=0;for(t=l.length;s<t;){if(f[--t]<l[t]){for(r=t;r&&0===f[--r];)f[r]=P-1;--f[r],f[t]+=P}f[t]-=l[t]}for(;0===f[--o];)f.pop();for(;0===f[0];f.shift())--i;return f[0]?(n.d=f,n.e=k(f,i),N?_(n,u,c):n):new p(3===c?-0:0)},y.modulo=y.mod=function(n){var e,i=this,t=i.constructor;return n=new t(n),!i.d||!n.s||n.d&&!n.d[0]?new t(NaN):!n.d||i.d&&!i.d[0]?_(new t(i),t.precision,t.rounding):(N=!1,9==t.modulo?(e=F(i,n.abs(),0,3,1)).s*=n.s:e=F(i,n,0,t.modulo,1),e=e.times(n),N=!0,i.minus(e))},y.naturalExponential=y.exp=function(){return $(this)},y.naturalLogarithm=y.ln=function(){return W(this)},y.negated=y.neg=function(){var n=new this.constructor(this);return n.s=-n.s,_(n)},y.plus=y.add=function(n){var e,i,t,r,s,o,u,c,f,a,h=this,l=h.constructor;if(n=new l(n),!h.d||!n.d)return h.s&&n.s?h.d||(n=new l(n.d||h.s===n.s?h:NaN)):n=new l(NaN),n;if(h.s!=n.s)return n.s=-n.s,h.minus(n);if(f=h.d,a=n.d,u=l.precision,c=l.rounding,!f[0]||!a[0])return a[0]||(n=new l(h)),N?_(n,u,c):n;if(s=Z(h.e/R),t=Z(n.e/R),f=f.slice(),r=s-t){for((o=(o=r<0?(i=f,r=-r,a.length):(i=a,t=s,f.length))<(s=Math.ceil(u/R))?s+1:o+1)<r&&(r=o,i.length=1),i.reverse();r--;)i.push(0);i.reverse()}for((o=f.length)-(r=a.length)<0&&(r=o,i=a,a=f,f=i),e=0;r;)e=(f[--r]=f[r]+a[r]+e)/P|0,f[r]%=P;for(e&&(f.unshift(e),++t),o=f.length;0==f[--o];)f.pop();return n.d=f,n.e=k(f,t),N?_(n,u,c):n},y.precision=y.sd=function(n){var e;if(void 0!==n&&n!==!!n&&1!==n&&0!==n)throw Error(w+n);return this.d?(e=H(this.d),n&&this.e+1>e&&(e=this.e+1)):e=NaN,e},y.round=function(){var n=this.constructor;return _(new n(this),this.e+1,n.rounding)},y.sine=y.sin=function(){var n,e,i=this,t=i.constructor;return i.isFinite()?i.isZero()?new t(i):(n=t.precision,e=t.rounding,t.precision=n+Math.max(i.e,i.sd())+R,t.rounding=1,i=function(n,e){var i,t=e.d.length;if(t<3)return G(n,2,e,e);i=16<(i=1.4*Math.sqrt(t))?16:0|i,e=e.times(1/K(5,i)),e=G(n,2,e,e);for(var r,s=new n(5),o=new n(16),u=new n(20);i--;)r=e.times(e),e=e.times(s.plus(r.times(o.times(r).minus(u))));return e}(t,Q(t,i)),t.precision=n,t.rounding=e,_(2<o?i.neg():i,n,e,!0)):new t(NaN)},y.squareRoot=y.sqrt=function(){var n,e,i,t,r,s,o=this,u=o.d,c=o.e,f=o.s,a=o.constructor;if(1!==f||!u||!u[0])return new a(!f||f<0&&(!u||u[0])?NaN:u?o:1/0);for(N=!1,t=0==(f=Math.sqrt(+o))||f==1/0?(((e=M(u)).length+c)%2==0&&(e+="0"),f=Math.sqrt(e),c=Z((c+1)/2)-(c<0||c%2),new a(e=f==1/0?"5e"+c:(e=f.toExponential()).slice(0,e.indexOf("e")+1)+c)):new a(f.toString()),i=(c=a.precision)+3;;)if(t=(s=t).plus(F(o,s,i+2,1)).times(.5),M(s.d).slice(0,i)===(e=M(t.d)).slice(0,i)){if("9999"!=(e=e.slice(i-3,i+1))&&(r||"4999"!=e)){+e&&(+e.slice(1)||"5"!=e.charAt(0))||(_(t,c+1,1),n=!t.times(t).eq(o));break}if(!r&&(_(s,c+1,0),s.times(s).eq(o))){t=s;break}i+=4,r=1}return N=!0,_(t,c,a.rounding,n)},y.tangent=y.tan=function(){var n,e,i=this,t=i.constructor;return i.isFinite()?i.isZero()?new t(i):(n=t.precision,e=t.rounding,t.precision=n+10,t.rounding=1,(i=i.sin()).s=1,i=F(i,new t(1).minus(i.times(i)).sqrt(),n+10,0),t.precision=n,t.rounding=e,_(2==o||4==o?i.neg():i,n,e,!0)):new t(NaN)},y.times=y.mul=function(n){var e,i,t,r,s,o,u,c,f,a=this.constructor,h=this.d,l=(n=new a(n)).d;if(n.s*=this.s,!(h&&h[0]&&l&&l[0]))return new a(!n.s||h&&!h[0]&&!l||l&&!l[0]&&!h?NaN:h&&l?0*n.s:n.s/0);for(i=Z(this.e/R)+Z(n.e/R),(c=h.length)<(f=l.length)&&(s=h,h=l,l=s,o=c,c=f,f=o),s=[],t=o=c+f;t--;)s.push(0);for(t=f;0<=--t;){for(e=0,r=c+t;t<r;)u=s[r]+l[t]*h[r-t-1]+e,s[r--]=u%P|0,e=u/P|0;s[r]=(s[r]+e)%P|0}for(;!s[--o];)s.pop();return e?++i:s.shift(),n.d=s,n.e=k(s,i),N?_(n,a.precision,a.rounding):n},y.toBinary=function(n,e){return X(this,2,n,e)},y.toDecimalPlaces=y.toDP=function(n,e){var i=this.constructor,t=new i(this);return void 0===n?t:(q(n,0,g),void 0===e?e=i.rounding:q(e,0,8),_(t,n+t.e+1,e))},y.toExponential=function(n,e){var i=this,t=i.constructor,r=void 0===n?A(i,!0):(q(n,0,g),void 0===e?e=t.rounding:q(e,0,8),A(i=_(new t(i),n+1,e),!0,n+1));return i.isNeg()&&!i.isZero()?"-"+r:r},y.toFixed=function(n,e){var i,t=this,r=t.constructor,s=void 0===n?A(t):(q(n,0,g),void 0===e?e=r.rounding:q(e,0,8),A(i=_(new r(t),n+t.e+1,e),!1,n+i.e+1));return t.isNeg()&&!t.isZero()?"-"+s:s},y.toFraction=function(n){var e,i,t,r,s,o,u,c,f,a,h,l,d=this,p=d.d,g=d.constructor;if(!p)return new g(d);if(f=i=new g(1),t=c=new g(0),o=(s=(e=new g(t)).e=H(p)-d.e-1)%R,e.d[0]=v(10,o<0?R+o:o),null==n)n=0<s?e:f;else{if(!(u=new g(n)).isInt()||u.lt(f))throw Error(w+u);n=u.gt(e)?0<s?e:f:u}for(N=!1,u=new g(M(p)),a=g.precision,g.precision=s=p.length*R*2;h=F(u,e,0,1,1),1!=(r=i.plus(h.times(t))).cmp(n);)i=t,t=r,r=f,f=c.plus(h.times(r)),c=r,r=e,e=u.minus(h.times(r)),u=r;return r=F(n.minus(i),t,0,1,1),c=c.plus(r.times(f)),i=i.plus(r.times(t)),c.s=f.s=d.s,l=F(f,t,s,1).minus(d).abs().cmp(F(c,i,s,1).minus(d).abs())<1?[f,t]:[c,i],g.precision=a,N=!0,l},y.toHexadecimal=y.toHex=function(n,e){return X(this,16,n,e)},y.toNearest=function(n,e){var i=(t=this).constructor,t=new i(t);if(null==n){if(!t.d)return t;n=new i(1),e=i.rounding}else{if(n=new i(n),void 0===e?e=i.rounding:q(e,0,8),!t.d)return n.s?t:n;if(!n.d)return n.s&&(n.s=t.s),n}return n.d[0]?(N=!1,t=F(t,n,0,e,1).times(n),N=!0,_(t)):(n.s=t.s,t=n),t},y.toNumber=function(){return+this},y.toOctal=function(n,e){return X(this,8,n,e)},y.toPower=y.pow=function(n){var e,i,t,r,s,o,u=this,c=u.constructor,f=+(n=new c(n));if(!(u.d&&n.d&&u.d[0]&&n.d[0]))return new c(v(+u,f));if((u=new c(u)).eq(1))return u;if(t=c.precision,s=c.rounding,n.eq(1))return _(u,t,s);if((e=Z(n.e/R))>=n.d.length-1&&(i=f<0?-f:f)<=9007199254740991)return r=V(c,u,i,t),n.s<0?new c(1).div(r):_(r,t,s);if((o=u.s)<0){if(e<n.d.length-1)return new c(NaN);if(0==(1&n.d[e])&&(o=1),0==u.e&&1==u.d[0]&&1==u.d.length)return u.s=o,u}return(e=0!=(i=v(+u,f))&&isFinite(i)?new c(i+"").e:Z(f*(Math.log("0."+M(u.d))/Math.LN10+u.e+1)))>c.maxE+1||e<c.minE-1?new c(0<e?o/0:0):(N=!1,c.rounding=u.s=1,i=Math.min(12,(e+"").length),(r=$(n.times(W(u,t+i)),t)).d&&O((r=_(r,t+5,1)).d,t,s)&&(e=t+10,+M((r=_($(n.times(W(u,e+i)),e),e+5,1)).d).slice(t+1,t+15)+1==1e14&&(r=_(r,t+1,0))),r.s=o,N=!0,_(r,t,c.rounding=s))},y.toPrecision=function(n,e){var i=this,t=i.constructor,r=void 0===n?A(i,i.e<=t.toExpNeg||i.e>=t.toExpPos):(q(n,1,g),void 0===e?e=t.rounding:q(e,0,8),A(i=_(new t(i),n,e),n<=i.e||i.e<=t.toExpNeg,n));return i.isNeg()&&!i.isZero()?"-"+r:r},y.toSignificantDigits=y.toSD=function(n,e){var i=this.constructor;return void 0===n?(n=i.precision,e=i.rounding):(q(n,1,g),void 0===e?e=i.rounding:q(e,0,8)),_(new i(this),n,e)},y.toString=function(){var n=this,e=n.constructor,i=A(n,n.e<=e.toExpNeg||n.e>=e.toExpPos);return n.isNeg()&&!n.isZero()?"-"+i:i},y.truncated=y.trunc=function(){return _(new this.constructor(this),this.e+1,1)},y.valueOf=y.toJSON=function(){var n=this,e=n.constructor,i=A(n,n.e<=e.toExpNeg||n.e>=e.toExpPos);return n.isNeg()?"-"+i:i};var F=function(n,e,i,t,r,s){var o,u,c,f,a,h,l,d,p,g,m,w,v,N,b,E,x,y,M,q,O=n.constructor,D=n.s==e.s?1:-1,F=n.d,A=e.d;if(!(F&&F[0]&&A&&A[0]))return new O(n.s&&e.s&&(F?!A||F[0]!=A[0]:A)?F&&0==F[0]||!A?0*D:D/0:NaN);for(u=s?(a=1,n.e-e.e):(s=P,a=R,Z(n.e/a)-Z(e.e/a)),M=A.length,x=F.length,g=(p=new O(D)).d=[],c=0;A[c]==(F[c]||0);c++);if(A[c]>(F[c]||0)&&u--,null==i?(N=i=O.precision,t=O.rounding):N=r?i+(n.e-e.e)+1:i,N<0)g.push(1),h=!0;else{if(N=N/a+2|0,c=0,1==M){for(A=A[f=0],N++;(c<x||f)&&N--;c++)b=f*s+(F[c]||0),g[c]=b/A|0,f=b%A|0;h=f||c<x}else{for(1<(f=s/(A[0]+1)|0)&&(A=L(A,f,s),F=L(F,f,s),M=A.length,x=F.length),E=M,w=(m=F.slice(0,M)).length;w<M;)m[w++]=0;for((q=A.slice()).unshift(0),y=A[0],A[1]>=s/2&&++y;f=0,(o=T(A,m,M,w))<0?(v=m[0],M!=w&&(v=v*s+(m[1]||0)),1<(f=v/y|0)?(s<=f&&(f=s-1),1==(o=T(l=L(A,f,s),m,d=l.length,w=m.length))&&(f--,U(l,M<d?q:A,d,s))):(0==f&&(o=f=1),l=A.slice()),(d=l.length)<w&&l.unshift(0),U(m,l,w,s),-1==o&&(o=T(A,m,M,w=m.length))<1&&(f++,U(m,M<w?q:A,w,s)),w=m.length):0===o&&(f++,m=[0]),g[c++]=f,o&&m[0]?m[w++]=F[E]||0:(m=[F[E]],w=1),(E++<x||void 0!==m[0])&&N--;);h=void 0!==m[0]}g[0]||g.shift()}if(1==a)p.e=u,S=h;else{for(c=1,f=g[0];10<=f;f/=10)c++;p.e=c+u*a-1,_(p,r?i+p.e+1:i,t,h)}return p};function L(n,e,i){var t,r=0,s=n.length;for(n=n.slice();s--;)t=n[s]*e+r,n[s]=t%i|0,r=t/i|0;return r&&n.unshift(r),n}function T(n,e,i,t){var r,s;if(i!=t)s=t<i?1:-1;else for(r=s=0;r<i;r++)if(n[r]!=e[r]){s=n[r]>e[r]?1:-1;break}return s}function U(n,e,i,t){for(var r=0;i--;)n[i]-=r,r=n[i]<e[i]?1:0,n[i]=r*t+n[i]-e[i];for(;!n[0]&&1<n.length;)n.shift()}function _(n,e,i,t){var r,s,o,u,c,f,a,h,l,d=n.constructor;n:if(null!=e){if(!(h=n.d))return n;for(r=1,u=h[0];10<=u;u/=10)r++;if((s=e-r)<0)s+=R,o=e,c=(a=h[l=0])/v(10,r-o-1)%10|0;else if(l=Math.ceil((s+1)/R),(u=h.length)<=l){if(!t)break n;for(;u++<=l;)h.push(0);a=c=0,o=(s%=R)-R+(r=1)}else{for(a=u=h[l],r=1;10<=u;u/=10)r++;c=(o=(s%=R)-R+r)<0?0:a/v(10,r-o-1)%10|0}if(t=t||e<0||void 0!==h[l+1]||(o<0?a:a%v(10,r-o-1)),f=i<4?(c||t)&&(0==i||i==(n.s<0?3:2)):5<c||5==c&&(4==i||t||6==i&&(0<s?0<o?a/v(10,r-o):0:h[l-1])%10&1||i==(n.s<0?8:7)),e<1||!h[0])return h.length=0,f?(e-=n.e+1,h[0]=v(10,(R-e%R)%R),n.e=-e||0):h[0]=n.e=0,n;if(0==s?(h.length=l,u=1,l--):(h.length=l+1,u=v(10,R-s),h[l]=0<o?(a/v(10,r-o)%v(10,o)|0)*u:0),f)for(;;){if(0==l){for(s=1,o=h[0];10<=o;o/=10)s++;for(o=h[0]+=u,u=1;10<=o;o/=10)u++;s!=u&&(n.e++,h[0]==P&&(h[0]=1));break}if(h[l]+=u,h[l]!=P)break;h[l--]=0,u=1}for(s=h.length;0===h[--s];)h.pop()}return N&&(n.e>d.maxE?(n.d=null,n.e=NaN):n.e<d.minE&&(n.e=0,n.d=[0])),n}function A(n,e,i){if(!n.isFinite())return J(n);var t,r=n.e,s=M(n.d),o=s.length;return e?(i&&0<(t=i-o)?s=s.charAt(0)+"."+s.slice(1)+B(t):1<o&&(s=s.charAt(0)+"."+s.slice(1)),s=s+(n.e<0?"e":"e+")+n.e):r<0?(s="0."+B(-r-1)+s,i&&0<(t=i-o)&&(s+=B(t))):o<=r?(s+=B(r+1-o),i&&0<(t=i-r-1)&&(s=s+"."+B(t))):((t=r+1)<o&&(s=s.slice(0,t)+"."+s.slice(t)),i&&0<(t=i-o)&&(r+1===o&&(s+="."),s+=B(t))),s}function k(n,e){var i=n[0];for(e*=R;10<=i;i/=10)e++;return e}function C(n,e,i){if(E<e)throw N=!0,i&&(n.precision=i),Error(s);return _(new n(t),e,1,!0)}function I(n,e,i){if(x<e)throw Error(s);return _(new n(r),e,i,!0)}function H(n){var e=n.length-1,i=e*R+1;if(e=n[e]){for(;e%10==0;e/=10)i--;for(e=n[0];10<=e;e/=10)i++}return i}function B(n){for(var e="";n--;)e+="0";return e}function V(n,e,i,t){var r,s=new n(1),o=Math.ceil(t/R+4);for(N=!1;;){if(i%2&&Y((s=s.times(e)).d,o)&&(r=!0),0===(i=Z(i/2))){i=s.d.length-1,r&&0===s.d[i]&&++s.d[i];break}Y((e=e.times(e)).d,o)}return N=!0,s}function j(n){return 1&n.d[n.d.length-1]}function i(n,e,i){for(var t,r=new n(e[0]),s=0;++s<e.length;){if(!(t=new n(e[s])).s){r=t;break}r[i](t)&&(r=t)}return r}function $(n,e){var i,t,r,s,o,u,c,f=0,a=0,h=0,l=n.constructor,d=l.rounding,p=l.precision;if(!n.d||!n.d[0]||17<n.e)return new l(n.d?n.d[0]?n.s<0?0:1/0:1:n.s?n.s<0?0:n:NaN);for(c=null==e?(N=!1,p):e,u=new l(.03125);-2<n.e;)n=n.times(u),h+=5;for(c+=t=Math.log(v(2,h))/Math.LN10*2+5|0,i=s=o=new l(1),l.precision=c;;){if(s=_(s.times(n),c,1),i=i.times(++a),M((u=o.plus(F(s,i,c,1))).d).slice(0,c)===M(o.d).slice(0,c)){for(r=h;r--;)o=_(o.times(o),c,1);if(null!=e)return l.precision=p,o;if(!(f<3&&O(o.d,c-t,d,f)))return _(o,l.precision=p,d,N=!0);l.precision=c+=10,i=s=u=new l(1),a=0,f++}o=u}}function W(n,e){var i,t,r,s,o,u,c,f,a,h,l,d=1,p=n,g=p.d,m=p.constructor,w=m.rounding,v=m.precision;if(p.s<0||!g||!g[0]||!p.e&&1==g[0]&&1==g.length)return new m(g&&!g[0]?-1/0:1!=p.s?NaN:g?0:p);if(a=null==e?(N=!1,v):e,m.precision=a+=10,t=(i=M(g)).charAt(0),!(Math.abs(s=p.e)<15e14))return f=C(m,a+2,v).times(s+""),p=W(new m(t+"."+i.slice(1)),a-10).plus(f),m.precision=v,null==e?_(p,v,w,N=!0):p;for(;t<7&&1!=t||1==t&&3<i.charAt(1);)t=(i=M((p=p.times(n)).d)).charAt(0),d++;for(s=p.e,1<t?(p=new m("0."+i),s++):p=new m(t+"."+i.slice(1)),c=o=p=F((h=p).minus(1),p.plus(1),a,1),l=_(p.times(p),a,1),r=3;;){if(o=_(o.times(l),a,1),M((f=c.plus(F(o,new m(r),a,1))).d).slice(0,a)===M(c.d).slice(0,a)){if(c=c.times(2),0!==s&&(c=c.plus(C(m,a+2,v).times(s+""))),c=F(c,new m(d),a,1),null!=e)return m.precision=v,c;if(!O(c.d,a-10,w,u))return _(c,m.precision=v,w,N=!0);m.precision=a+=10,f=o=p=F(h.minus(1),h.plus(1),a,1),l=_(p.times(p),a,1),r=u=1}c=f,r+=2}}function J(n){return String(n.s*n.s/0)}function z(n,e){var i,t,r;for(-1<(i=e.indexOf("."))&&(e=e.replace(".","")),0<(t=e.search(/e/i))?(i<0&&(i=t),i+=+e.slice(t+1),e=e.substring(0,t)):i<0&&(i=e.length),t=0;48===e.charCodeAt(t);t++);for(r=e.length;48===e.charCodeAt(r-1);--r);if(e=e.slice(t,r)){if(r-=t,n.e=i=i-t-1,n.d=[],t=(i+1)%R,i<0&&(t+=R),t<r){for(t&&n.d.push(+e.slice(0,t)),r-=R;t<r;)n.d.push(+e.slice(t,t+=R));e=e.slice(t),t=R-e.length}else t-=r;for(;t--;)e+="0";n.d.push(+e),N&&(n.e>n.constructor.maxE?(n.d=null,n.e=NaN):n.e<n.constructor.minE&&(n.e=0,n.d=[0]))}else n.e=0,n.d=[0];return n}function G(n,e,i,t,r){var s,o,u,c,f=n.precision,a=Math.ceil(f/R);for(N=!1,c=i.times(i),u=new n(t);;){if(o=F(u.times(c),new n(e++*e++),f,1),u=r?t.plus(o):t.minus(o),t=F(o.times(c),new n(e++*e++),f,1),void 0!==(o=u.plus(t)).d[a]){for(s=a;o.d[s]===u.d[s]&&s--;);if(-1==s)break}s=u,u=t,t=o,o=s,0}return N=!0,o.d.length=a+1,o}function K(n,e){for(var i=n;--e;)i*=n;return i}function Q(n,e){var i,t=e.s<0,r=I(n,n.precision,1),s=r.times(.5);if((e=e.abs()).lte(s))return o=t?4:1,e;if((i=e.divToInt(r)).isZero())o=t?3:2;else{if((e=e.minus(i.times(r))).lte(s))return o=j(i)?t?2:3:t?4:1,e;o=j(i)?t?1:4:t?3:2}return e.minus(r).abs()}function X(n,e,i,t){var r,s,o,u,c,f,a,h,l,d=n.constructor,p=void 0!==i;if(p?(q(i,1,g),void 0===t?t=d.rounding:q(t,0,8)):(i=d.precision,t=d.rounding),n.isFinite()){for(p?(r=2,16==e?i=4*i-3:8==e&&(i=3*i-2)):r=e,0<=(o=(a=A(n)).indexOf("."))&&(a=a.replace(".",""),(l=new d(1)).e=a.length-o,l.d=D(A(l),10,r),l.e=l.d.length),s=c=(h=D(a,10,r)).length;0==h[--c];)h.pop();if(h[0]){if(o<0?s--:((n=new d(n)).d=h,n.e=s,h=(n=F(n,l,i,t,0,r)).d,s=n.e,f=S),o=h[i],u=r/2,f=f||void 0!==h[i+1],f=t<4?(void 0!==o||f)&&(0===t||t===(n.s<0?3:2)):u<o||o===u&&(4===t||f||6===t&&1&h[i-1]||t===(n.s<0?8:7)),h.length=i,f)for(;++h[--i]>r-1;)h[i]=0,i||(++s,h.unshift(1));for(c=h.length;!h[c-1];--c);for(o=0,a="";o<c;o++)a+=m.charAt(h[o]);if(p){if(1<c)if(16==e||8==e){for(o=16==e?4:3,--c;c%o;c++)a+="0";for(c=(h=D(a,r,e)).length;!h[c-1];--c);for(o=1,a="1.";o<c;o++)a+=m.charAt(h[o])}else a=a.charAt(0)+"."+a.slice(1);a=a+(s<0?"p":"p+")+s}else if(s<0){for(;++s;)a="0"+a;a="0."+a}else if(++s>c)for(s-=c;s--;)a+="0";else s<c&&(a=a.slice(0,s)+"."+a.slice(s))}else a=p?"0p+0":"0";a=(16==e?"0x":2==e?"0b":8==e?"0o":"")+a}else a=J(n);return n.s<0?"-"+a:a}function Y(n,e){return n.length>e&&(n.length=e,1)}function nn(n){return new this(n).abs()}function en(n){return new this(n).acos()}function tn(n){return new this(n).acosh()}function rn(n,e){return new this(n).plus(e)}function sn(n){return new this(n).asin()}function on(n){return new this(n).asinh()}function un(n){return new this(n).atan()}function cn(n){return new this(n).atanh()}function fn(n,e){n=new this(n),e=new this(e);var i,t=this.precision,r=this.rounding,s=t+4;return n.s&&e.s?n.d||e.d?!e.d||n.isZero()?(i=e.s<0?I(this,t,r):new this(0)).s=n.s:!n.d||e.isZero()?(i=I(this,s,1).times(.5)).s=n.s:i=e.s<0?(this.precision=s,this.rounding=1,i=this.atan(F(n,e,s,1)),e=I(this,s,1),this.precision=t,this.rounding=r,n.s<0?i.minus(e):i.plus(e)):this.atan(F(n,e,s,1)):(i=I(this,s,1).times(0<e.s?.25:.75)).s=n.s:i=new this(NaN),i}function an(n){return new this(n).cbrt()}function hn(n){return _(n=new this(n),n.e+1,2)}function ln(n){if(!n||"object"!=typeof n)throw Error(f+"Object expected");for(var e,i,t=!0===n.defaults,r=["precision",1,g,"rounding",0,8,"toExpNeg",-u,0,"toExpPos",0,u,"maxE",0,u,"minE",-u,0,"modulo",0,9],s=0;s<r.length;s+=3)if(e=r[s],t&&(this[e]=c[e]),void 0!==(i=n[e])){if(!(Z(i)===i&&r[s+1]<=i&&i<=r[s+2]))throw Error(w+e+": "+i);this[e]=i}if(e="crypto",t&&(this[e]=c[e]),void 0!==(i=n[e])){if(!0!==i&&!1!==i&&0!==i&&1!==i)throw Error(w+e+": "+i);if(i){if("undefined"==typeof crypto||!crypto||!crypto.getRandomValues&&!crypto.randomBytes)throw Error(a);this[e]=!0}else this[e]=!1}return this}function dn(n){return new this(n).cos()}function pn(n){return new this(n).cosh()}function gn(n,e){return new this(n).div(e)}function mn(n){return new this(n).exp()}function wn(n){return _(n=new this(n),n.e+1,3)}function vn(){var n,e,i=new this(0);for(N=!1,n=0;n<arguments.length;)if((e=new this(arguments[n++])).d)i.d&&(i=i.plus(e.times(e)));else{if(e.s)return N=!0,new this(1/0);i=e}return N=!0,i.sqrt()}function Nn(n){return n instanceof h||n&&"[object Decimal]"===n.name||!1}function bn(n){return new this(n).ln()}function En(n,e){return new this(n).log(e)}function xn(n){return new this(n).log(2)}function yn(n){return new this(n).log(10)}function Mn(){return i(this,arguments,"lt")}function qn(){return i(this,arguments,"gt")}function On(n,e){return new this(n).mod(e)}function Dn(n,e){return new this(n).mul(e)}function Fn(n,e){return new this(n).pow(e)}function An(n){var e,i,t,r,s=0,o=new this(1),u=[];if(void 0===n?n=this.precision:q(n,1,g),t=Math.ceil(n/R),this.crypto)if(crypto.getRandomValues)for(e=crypto.getRandomValues(new Uint32Array(t));s<t;)429e7<=(r=e[s])?e[s]=crypto.getRandomValues(new Uint32Array(1))[0]:u[s++]=r%1e7;else{if(!crypto.randomBytes)throw Error(a);for(e=crypto.randomBytes(t*=4);s<t;)214e7<=(r=e[s]+(e[s+1]<<8)+(e[s+2]<<16)+((127&e[s+3])<<24))?crypto.randomBytes(4).copy(e,s):(u.push(r%1e7),s+=4);s=t/4}else for(;s<t;)u[s++]=1e7*Math.random()|0;for(t=u[--s],n%=R,t&&n&&(r=v(10,R-n),u[s]=(t/r|0)*r);0===u[s];s--)u.pop();if(s<0)u=[i=0];else{for(i=-1;0===u[0];i-=R)u.shift();for(t=1,r=u[0];10<=r;r/=10)t++;t<R&&(i-=R-t)}return o.e=i,o.d=u,o}function Sn(n){return _(n=new this(n),n.e+1,this.rounding)}function Zn(n){return(n=new this(n)).d?n.d[0]?n.s:0*n.s:n.s||NaN}function Pn(n){return new this(n).sin()}function Rn(n){return new this(n).sinh()}function Ln(n){return new this(n).sqrt()}function Tn(n,e){return new this(n).sub(e)}function Un(n){return new this(n).tan()}function _n(n){return new this(n).tanh()}function kn(n){return _(n=new this(n),n.e+1,1)}(h=function n(e){var i,t,r;function s(n){var e,i,t,r=this;if(!(r instanceof s))return new s(n);if(n instanceof(r.constructor=s))return r.s=n.s,void(N?!n.d||n.e>s.maxE?(r.e=NaN,r.d=null):n.e<s.minE?(r.e=0,r.d=[0]):(r.e=n.e,r.d=n.d.slice()):(r.e=n.e,r.d=n.d?n.d.slice():n.d));if("number"==(t=typeof n)){if(0===n)return r.s=1/n<0?-1:1,r.e=0,void(r.d=[0]);if(n<0?(n=-n,r.s=-1):r.s=1,n===~~n&&n<1e7){for(e=0,i=n;10<=i;i/=10)e++;return void(N?s.maxE<e?(r.e=NaN,r.d=null):e<s.minE?(r.e=0,r.d=[0]):(r.e=e,r.d=[n]):(r.e=e,r.d=[n]))}return 0*n!=0?(n||(r.s=NaN),r.e=NaN,void(r.d=null)):z(r,n.toString())}if("string"!=t)throw Error(w+n);return 45===(i=n.charCodeAt(0))?(n=n.slice(1),r.s=-1):(43===i&&(n=n.slice(1)),r.s=1),(b.test(n)?z:function(n,e){var i,t,r,s,o,u,c,f,a;if("Infinity"===e||"NaN"===e)return+e||(n.s=NaN),n.e=NaN,n.d=null,n;if(d.test(e))i=16,e=e.toLowerCase();else if(l.test(e))i=2;else{if(!p.test(e))throw Error(w+e);i=8}for(o=0<=(s=(e=0<(s=e.search(/p/i))?(c=+e.slice(s+1),e.substring(2,s)):e.slice(2)).indexOf(".")),t=n.constructor,o&&(s=(u=(e=e.replace(".","")).length)-s,r=V(t,new t(i),s,2*s)),s=a=(f=D(e,i,P)).length-1;0===f[s];--s)f.pop();return s<0?new t(0*n.s):(n.e=k(f,a),n.d=f,N=!1,o&&(n=F(n,r,4*u)),c&&(n=n.times(Math.abs(c)<54?v(2,c):h.pow(2,c))),N=!0,n)})(r,n)}if(s.prototype=y,s.ROUND_UP=0,s.ROUND_DOWN=1,s.ROUND_CEIL=2,s.ROUND_FLOOR=3,s.ROUND_HALF_UP=4,s.ROUND_HALF_DOWN=5,s.ROUND_HALF_EVEN=6,s.ROUND_HALF_CEIL=7,s.ROUND_HALF_FLOOR=8,s.EUCLID=9,s.config=s.set=ln,s.clone=n,s.isDecimal=Nn,s.abs=nn,s.acos=en,s.acosh=tn,s.add=rn,s.asin=sn,s.asinh=on,s.atan=un,s.atanh=cn,s.atan2=fn,s.cbrt=an,s.ceil=hn,s.cos=dn,s.cosh=pn,s.div=gn,s.exp=mn,s.floor=wn,s.hypot=vn,s.ln=bn,s.log=En,s.log10=yn,s.log2=xn,s.max=Mn,s.min=qn,s.mod=On,s.mul=Dn,s.pow=Fn,s.random=An,s.round=Sn,s.sign=Zn,s.sin=Pn,s.sinh=Rn,s.sqrt=Ln,s.sub=Tn,s.tan=Un,s.tanh=_n,s.trunc=kn,void 0===e&&(e={}),e&&!0!==e.defaults)for(r=["precision","rounding","toExpNeg","toExpPos","maxE","minE","modulo","crypto"],i=0;i<r.length;)e.hasOwnProperty(t=r[i++])||(e[t]=this[t]);return s.config(e),s}(c)).default=h.Decimal=h,t=new h(t),r=new h(r),"function"==typeof define&&define.amd?define(function(){return h}):"undefined"!=typeof module&&module.exports?("function"==typeof Symbol&&"symbol"==typeof Symbol.iterator&&(y[Symbol.for("nodejs.util.inspect.custom")]=y.toString,y[Symbol.toStringTag]="Decimal"),module.exports=h):(n=n||("undefined"!=typeof self&&self&&self.self==self?self:window),e=n.Decimal,h.noConflict=function(){return n.Decimal=e,h},n.Decimal=h)}(this);
+</script>
+<script id="bank_app" version=0.6>
+    const bank_app = {
+
+        launchApp: function(reqCallback, resCallback) {
+            return new Promise((resolve, reject) => {
+                let data = ["requests", "responses", "appendix", "settings"];
+                Promise.all(data.map(d => compactIDB.readAllData(d))).then(results => {
+                    console.debug(data, results)
+                    for (let i in results)
+                        this[data[i]] = results[i];
+                    this.refreshData(true).then(result => {
+                        //setInterval(() => this.refreshData(), this.util.refreshTime);
+                        console.log(result);
+                        this.readDataFromCloud(myFloID === floGlobals.adminID, reqCallback, resCallback)
+                            .then(result => resolve(result))
+                            .catch(error => reject(error))
+                    }).catch(error => reject(error))
+                }).catch(error => reject(error))
             })
         },
 
-        viewInbox() {
-            let inbox = floDapps.getNextGeneralData("directMessage", '0', {decrypt: true});
-            return inbox;
+        util: {
+            lastUpdate: null,
+            secInYr: new Decimal(31556952000),
+            refreshTime: 5 * 60000, //min*millisec
+            delta: 1.001,
+            istr: floGlobals.application + '::'
         },
 
-        sendDirectMessage(message, receiver, receiverPubKey = null) {
+        settings: {},
+        model: {},
+        constants: {},
+        accMap: {},
+        accounts: [],
+        rates: {},
+
+        refreshData: function(reset = false) {
             return new Promise((resolve, reject) => {
-                if (receiverPubKey && floCrypto.getFloIDfromPubkeyHex(receiverPubKey) != receiver) 
-                        return reject("receiver Public-key mismatch")
-                floCloudAPI.sendGeneralData(message, "directMessage", {
-                        receiverID: receiver,
-                        encrypt: receiverPubKey
-                    })
+                this.readDataFromBlockchain().then(accounts => {
+                    if (reset) {
+                        ["I_b", "I_s"].forEach(m => this.model[m] = this.exParser(this.settings[m]));
+                        for (let s in this.settings)
+                            if (s.startsWith("constant-"))
+                                this.constants[s.substring("constant-".length)] = this.settings[s]
+                        compactIDB.readAllData('accounts').then(accounts => {
+                            this.util.lastUpdate = null;
+                            this.accMap = {};
+                            this.accounts = [];
+                            this.rates = {};
+                            for (let a in accounts)
+                                this.parseAccount(a, accounts[a].data, accounts[a].txid);
+                            this.updateAccountNetValues();
+                            resolve("Data Refreshed with sync from localDB");
+                        }).catch(error => reject(error))
+                    } else {
+                        try {
+                            for (let a in accounts)
+                                this.parseAccount(a, accounts[a].data, accounts[a].txid);
+                            this.updateAccountNetValues();
+                            resolve("Data Refreshed");
+                        } catch (error) {
+                            console.error(error)
+                            this.refreshData(true)
+                                .then(result => resolve(result))
+                                .catch(error => reject(error))
+                        }
+                    }
+
+                }).catch(error => reject(error))
+            })
+        },
+
+        readDataFromCloud: function(isAdmin, reqCallback, resCallback) {
+            if (isAdmin)
+                return floCloudAPI.requestApplicationData("REQUEST", {
+                    receiverID: floGlobals.adminID,
+                    senderIDs: false,
+                    lowerVectorClock: this.appendix.lastRequest + 1,
+                    callback: (d, e) => {
+                        let r = {};
+                        for (let x in d) {
+                            r[x] = {}
+                            for (let y in d[x].message)
+                                r[x][y] = d[x].message[y];
+                            r[x].floID = d[x].senderID;
+                            r[x].pubKey = d[x].pubKey;
+                            r[x].status = "pending";
+                            this.requests[x] = r[x];
+                            compactIDB.addData("requests", r[x], x);
+                        }
+                        this.appendix.lastRequest = Object.keys(this.requests).sort().pop();
+                        compactIDB.writeData("appendix", this.appendix.lastRequest, "lastRequest");
+                        if (reqCallback instanceof Function)
+                            reqCallback(r, e);
+                    }
+                });
+            else {
+                let p1 = floCloudAPI.requestApplicationData("REQUEST", {
+                    receiverID: floGlobals.adminID,
+                    senderIDs: [myFloID],
+                    lowerVectorClock: this.appendix.lastRequest + 1,
+                    callback: (d, e) => {
+                        let r = {};
+                        for (let x in d) {
+                            r[x] = {}
+                            for (let y in d[x].message)
+                                r[x][y] = d[x].message[y];
+                            this.requests[x] = r[x];
+                            compactIDB.addData("requests", r[x], x);
+                        }
+                        this.appendix.lastRequest = Object.keys(this.requests).sort().pop();
+                        compactIDB.writeData("appendix", this.appendix.lastRequest, "lastRequest");
+                        if (reqCallback instanceof Function)
+                            reqCallback(r, e);
+                    }
+                });
+                let p2 = floCloudAPI.requestApplicationData("RESPONSE", {
+                    receiverID: myFloID,
+                    senderIDs: [floGlobals.adminID],
+                    lowerVectorClock: this.appendix.lastResponse + 1,
+                    callback: (d, e) => {
+                        let r = {};
+                        for (let x in d) {
+                            r[x] = {}
+                            for (let y in d[x].message)
+                                r[x][y] = d[x].message[y];
+                            this.responses[x] = r[x];
+                            compactIDB.addData("responses", r[x], x);
+                        }
+                        this.appendix.lastResponse = Object.keys(this.responses).sort().pop();
+                        compactIDB.writeData("appendix", this.appendix.lastResponse, "lastResponse");
+                        if (resCallback instanceof Function)
+                            resCallback(r, e);
+                    }
+                });
+                return Promise.all([p1, p2]);
+            }
+        },
+
+        readDataFromBlockchain: function() {
+            return new Promise((resolve, reject) => {
+                let options = {
+                    sentOnly: true,
+                    ignoreOld: this.appendix.lastTx,
+                    txid: true,
+                    filter: d => d.startsWith(this.util.istr)
+                }
+                floBlockchainAPI.readData(floGlobals.adminID, options).then(result => {
+                    let accounts = {},
+                        promises = [];
+                    result.data.reverse().forEach(d => {
+                        let data = d[1].substring(this.util.istr.length);
+                        try {
+                            if (data.startsWith("set:")) {
+                                let settings = JSON.parse(data.substring("set:".length))
+                                for (let s in settings) {
+                                    promises.push(compactIDB.writeData("settings", settings[s], s));
+                                    this.settings[s] = settings[s];
+                                }
+                            } else {
+                                let values = data.split('|');
+                                if (values.length > 1) {
+                                    let key = parseInt(values.shift());
+                                    if (isNaN(key)) return;
+                                    accounts[key] = {
+                                        data: values,
+                                        txid: d[0]
+                                    };
+                                    promises.push(compactIDB.addData('accounts', accounts[key], key));
+                                }
+                            }
+                        } catch (error) {
+                            console.error(error);
+                        }
+                    });
+                    Promise.all(promises).then(results => {
+                        this.appendix.lastTx = result.totalTxs
+                        compactIDB.writeData('appendix', result.totalTxs, "lastTx")
+                            .then(result => resolve(accounts))
+                            .catch(error => reject(error))
+                    }).catch(error => reject(error))
+                }).catch(error => reject(error))
+            })
+
+        },
+
+        dataConstruct: function(time, floID, type, index, sign, pubKey, amount = null, tokenTx = null) {
+            let data = [];
+            data.push(time);
+            data.push('floID:' + floID);
+            data.push(type + ":" + index);
+            if (amount)
+                data.push('amount:' + amount);
+            if (tokenTx)
+                data.push('token-tx:' + tokenTx);
+            data.push('sign:' + sign);
+            data.push('pubKey:' + pubKey);
+            console.debug(this.util.istr + data.join('|'));
+            return this.util.istr + data.join('|');
+        },
+
+        parseAccount: function(time, data, txid) {
+            let acc = {};
+            data.forEach(d => {
+                d = d.split(":");
+                switch (d[0]) {
+                    case "open-deposit":
+                    case "close-deposit":
+                    case "open-loan":
+                    case "close-loan":
+                        acc.type = d[0];
+                        acc.index = d[1];
+                        break;
+                    case "amount":
+                        acc.amount = parseFloat(d[1]);
+                        break;
+                    case "sign":
+                    case "pubKey":
+                    case "floID":
+                    case "token-tx":
+                        acc[d[0]] = d[1];
+                        break;
+                    default:
+                        console.warn("Unknown parse data", d);
+                }
+            });
+            console.debug(time, txid, acc);
+            if (!time || !txid || !acc.floID || !acc.type || !acc.index || !acc.sign || !acc.pubKey)
+                return;
+            switch (acc.type) {
+                case "open-deposit":
+                    if (floCrypto.verifySign(this.util.istr + `open#${acc.index}:deposit|${acc.amount}|${acc['token-tx']}`, acc.sign, acc.pubKey))
+                        this.addAccount(acc.floID, {
+                            floID: acc.floID,
+                            type: "deposit",
+                            amount: acc.amount,
+                            pubKey: acc.pubKey,
+                            sign: {
+                                open: acc.sign
+                            },
+                        }, time, txid, acc['token-tx']);
+                    break;
+                case "close-deposit":
+                    if (floCrypto.verifySign(this.util.istr + `close#${acc.index}:deposit`, acc.sign, acc.pubKey))
+                        this.closeAccount(acc.floID, acc.index, time, acc.sign, txid, acc['token-tx'] || txid);
+                    break;
+                case "open-loan":
+                    if (floCrypto.verifySign(this.util.istr + `open#${acc.index}:loan|${acc.amount}`, acc.sign, acc.pubKey))
+                        this.addAccount(acc.floID, {
+                            floID: acc.floID,
+                            type: "loan",
+                            amount: acc.amount,
+                            pubKey: acc.pubKey,
+                            sign: {
+                                open: acc.sign
+                            },
+                        }, time, txid, acc['token-tx'] || txid);
+                    break;
+                case "close-loan":
+                    if (floCrypto.verifySign(this.util.istr + `close#${acc.index}:loan|${acc['token-tx']}`, acc.sign, acc.pubKey))
+                        this.closeAccount(acc.floID, acc.index, time, acc.sign, txid, acc['token-tx']);
+                    break;
+            }
+        },
+
+        tokenAPI: {
+            fetch_api: function(apicall) {
+                return new Promise((resolve, reject) => {
+                    console.log(floGlobals.tokenURL + apicall);
+                    fetch(floGlobals.tokenURL + apicall).then(response => {
+                        if (response.ok)
+                            response.json().then(data => resolve(data));
+                        else
+                            reject(response)
+                    }).catch(error => reject(error))
+                })
+            },
+            getBalance: function(floID, token = floGlobals.token) {
+                return new Promise((resolve, reject) => {
+                    this.fetch_api(`api/v1.0/getFloAddressBalance?token=${token}&floAddress=${floID}`)
+                        .then(result => resolve(result.balance || 0))
+                        .catch(error => reject(error))
+                })
+            },
+            getTx: function(txID) {
+                return new Promise((resolve, reject) => {
+                    this.fetch_api(`api/v1.0/getTransactionDetails/${txID}`).then(res => {
+                        if (res.result === "error")
+                            return reject(res.description);
+                        else if (!res.parsedFloData)
+                            return reject("Data piece (parsedFloData) missing");
+                        else if (!res.transactionDetails)
+                            return reject("Data piece (transactionDetails) missing");
+                        let response = {
+                            amount: res.parsedFloData.tokenAmount,
+                            token: res.parsedFloData.tokenIdentification,
+                            transfer: res.parsedFloData.transferType,
+                            type: res.parsedFloData.type,
+                            time: res.transactionDetails.time,
+                            confirmations: res.transactionDetails.confirmations
+                        }
+                        response.sender = res.transactionDetails.vin[0].addr
+                        for (let i in res.transactionDetails.vout) {
+                            let vout = res.transactionDetails.vout[i];
+                            if (vout.scriptPubKey.addresses[0] !== response.sender) {
+                                response.receiver = vout.scriptPubKey.addresses[0]
+                                break;
+                            }
+                        }
+                        resolve(response)
+                    }).catch(error => reject(error))
+                })
+            },
+            sendToken: function(privKey, amount, message = "", receiverID = floGlobals.adminID, token = floGlobals.token) {
+                return new Promise((resolve, reject) => {
+                    let senderID = floCrypto.getFloID(privKey);
+                    if (typeof amount !== "number" || amount <= 0)
+                        return reject("Invalid amount");
+                    this.getBalance(senderID, token).then(bal => {
+                        if (amount > bal)
+                            return reject("Insufficiant balance");
+                        floBlockchainAPI.writeData(senderID, `send ${amount} ${token}# ${message}`, privKey, receiverID)
+                            .then(txid => resolve(txid))
+                            .catch(error => reject(error))
+                    }).catch(error => reject(error))
+                });
+            },
+            validateToken: function(tx, sender, receiver, amount = null, token = floGlobals.token) {
+                return ((!sender || tx.sender === sender) &&
+                    (!receiver || tx.receiver === receiver) &&
+                    (amount === null || tx.amount === amount) &&
+                    (token === tx.token));
+            },
+            verifyToken: function(txid, sender, receiver, amount = null, token = floGlobals.token) {
+                return new Promise((resolve, reject) => {
+                    this.getTx(tx).then(txn => {
+                        if (sender && txn.sender != sender)
+                            reject("Incorrect sender");
+                        else if (receiver && txn.receiver != receiver)
+                            reject("Incorrect receiver");
+                        else if (amount && txn.amount != amount)
+                            reject("Incorrect amount");
+                        else if (token != txn.token)
+                            reject("Incorrect token")
+                        else
+                            resolve(txn)
+                    }).catch(error => reject(error))
+                })
+            }
+
+        },
+
+        writeBankTxData: function(privKey, data, receiverID, tokenAmt = null, token = floGlobals.token) {
+            return new Promise((resolve, reject) => {
+                let senderID = floCrypto.getFloID(privKey);
+                if (senderID != floGlobals.adminID)
+                    return reject("Access Denied: Admin only!");
+                if (tokenAmt !== null) {
+                    if (typeof tokenAmt !== "number" || tokenAmt <= 0)
+                        return reject("Invalid token amount");
+                    this.tokenAPI.getBalance(senderID, token).then(bal => {
+                        if (tokenAmt > bal)
+                            return reject("Insufficiant balance");
+                        floBlockchainAPI.writeData(senderID, data + `| send ${tokenAmt} ${token}#`, privKey, receiverID)
+                            .then(txid => resolve(txid))
+                            .catch(error => reject(error))
+                    }).catch(error => reject(error))
+                } else {
+                    floBlockchainAPI.writeData(senderID, data, privKey, receiverID)
+                        .then(txid => resolve(txid))
+                        .catch(error => reject(error))
+                }
+            })
+        },
+
+        checkTxDuplicate: function(txid, floID = null) {
+            let accounts = [];
+            if (!floID)
+                accounts = this.accounts;
+            else
+                this.accMap[floID].forEach(i => accounts.push(this.accounts[i]));
+            for (let acc of accounts)
+                if (acc.openTx === txid || acc.closeTx === txid)
+                    return true;
+            return false;
+        },
+
+        addAccount: function(floID, account, time, txid, tokenTx) {
+            this.updateAccountNetValues(time);
+            account.netAmt = account.amount;
+            account.status = "active";
+            account.openTime = time;
+            account.openTx = txid;
+            account.openTokenTx = tokenTx;
+            let index = this.accounts.push(account);
+            index -= 1;
+            if (!this.accMap[floID])
+                this.accMap[floID] = [];
+            this.accMap[floID].push(index);
+            this.updateRates();
+        },
+
+        closeAccount: function(floID, index, time, sign, txid, tokenTx) {
+            let accIndex = this.accMap[floID][index];
+            if (typeof accIndex != "number")
+                throw Error("Invalid Account index");
+            let account = this.accounts[accIndex];
+            if (!account)
+                throw Error("Invalid Account: Account not found");
+            if (account.status === "closed")
+                throw Error("Invalid operation: Account already closed");
+            this.updateAccountNetValues(time);
+            account.status = "closed";
+            account.closeTime = time;
+            account.closeTx = txid;
+            account.closeTokenTx = tokenTx;
+            account.sign.close = sign;
+            this.updateRates();
+        },
+
+        updateAccountNetValues: function(time = Date.now()) {
+            if (this.util.lastUpdate > time)
+                throw Error("update time is already passed");
+            let t, rates = {};
+            rates["loan"] = this.rates["I_b"];
+            rates["deposit"] = this.rates["I_s"];
+            t = Decimal.sub(time, this.util.lastUpdate || time); //if lastUpdate is null, t becomes 0 ie, no update to values
+            t = t.div(this.util.secInYr);
+            this.accounts.forEach(acc => {
+                if (acc.status === "active")
+                    acc.netAmt = this.calcNetValue(acc.netAmt, rates[acc.type], t)
+            });
+            this.util.lastUpdate = time;
+        },
+
+        calcNetValue: function(P, r, t) {
+            let x, A;
+            //A = P*e^rt
+            x = Decimal.mul(r, t) //rt
+            x = Decimal.pow(Math.E, x) //e^rt
+            A = Decimal.mul(P, x) //P*e^rt
+            return A.toNumber();
+        },
+
+        calcUtilizationRate: function(toNum = true) {
+            let totalLoan = 0,
+                totalDeposit = 0;
+            for (let acc of this.accounts)
+                if (acc.status === "active") {
+                    switch (acc.type) {
+                        case "loan":
+                            totalLoan += acc.netAmt;
+                            break;
+                        case "deposit":
+                            totalDeposit += acc.netAmt;
+                            break;
+                    }
+                }
+            if (totalLoan === 0)
+                return toNum ? 0 : Decimal(0);
+            if (totalDeposit <= totalLoan)
+                throw ("total loan exceeds total deposit");
+            let U = Decimal.div(totalLoan, totalDeposit);
+            return toNum ? U.toNumber() : U;
+        },
+
+        calcBorrowingRate: function(U = null, toNum = true) {
+            if (U === null)
+                U = this.calcUtilizationRate(false);
+            let model = this.model["I_b"];
+            let constants = {}
+            for (let token of model)
+                if (typeof token === "string" && /^[\w]+$/.test(token))
+                    constants[token] = this.constants[token];
+            constants["U"] = U;
+            return this.evaluator(model, constants, toNum);
+        },
+
+        calcSavingRate: function(U = null, I_b = null, toNum = true) {
+            if (U === null)
+                U = this.calcUtilizationRate(false);
+            if (I_b === null)
+                I_b = this.calcBorrowingRate(U, false);
+            let model = this.model["I_s"];
+            let constants = {}
+            for (let token of model)
+                if (typeof token === "string" && /^[\w]+$/.test(token))
+                    constants[token] = this.constants[token];
+            constants["U"] = U;
+            constants["I_b"] = I_b;
+            return this.evaluator(model, constants, toNum);
+        },
+
+        calcRates: function(toNum = true) {
+            let U, I_b, I_s, result;
+            U = this.calcUtilizationRate(false);
+            I_b = this.calcBorrowingRate(U, false);
+            I_s = this.calcSavingRate(U, I_b, false);
+            if (toNum) {
+                U = U.toNumber();
+                I_b = I_b.toNumber();
+                I_s = I_s.toNumber();
+            }
+            return {
+                U,
+                I_b,
+                I_s
+            };
+        },
+
+        updateRates: function() {
+            this.rates = this.calcRates(false);
+            return this.rates;
+        },
+
+        getRates: function() {
+            let rates = {}
+            for (let x in this.rates)
+                rates[x] = this.rates[x].toNumber();
+            return rates;
+        },
+
+        getUserDetails: function(floID) {
+            let accList = this.accMap[floID]
+            let result = {
+                accounts: [],
+                depositTotal: 0,
+                loanTotal: 0
+            }
+            accList.forEach(i => {
+                let acc = this.accounts[i]
+                result.accounts.push(acc)
+                if (acc.status === "active")
+                    switch (acc.type) {
+                        case "deposit":
+                            result.depositTotal += acc.netAmt;
+                            break;
+                        case "loan":
+                            result.loanTotal += acc.netAmt;
+                            break;
+                    }
+            })
+            //Might need to add net interest calculations
+            result.netTotal = result.depositTotal - result.loanTotal;
+            return result
+        },
+
+        getAccount: function(floID, index) {
+            let mappedIndex = this.accMap[floID][index]
+            return this.accounts[mappedIndex];
+        },
+
+        exParser(expression) {
+            let infix = expression.replace(/\s/g, "").split(""); //tokenize
+            const p = ["-", "+", "*", "/", "^"]; //presedences order (low to high)
+            var opStack = [],
+                postfix = [];
+            //convert infix to postfix
+            for (let i = 0; i < infix.length; i++) {
+                //Constants or Numbers
+                if (/^\w$/.test(infix[i])) {
+                    if (/^\d$/.test(infix[i])) {
+                        let n = infix[i]
+                        while (/^[\d.]$/.test(infix[i + 1]))
+                            n += infix[++i];
+                        n = parseFloat(n)
+                        postfix.push(n)
+                    } else {
+                        let c = infix[i]
+                        while (/^[\w]$/.test(infix[i + 1]))
+                            c += infix[++i];
+                        postfix.push(c)
+                    }
+                    continue;
+                }
+                let top = opStack[opStack.length - 1],
+                    op = infix[i];
+                if (!opStack.length || top === "(" || op === "(")
+                    opStack.push(op)
+                else if (op === ")")
+                    if (opStack.includes('('))
+                        for (let o = opStack.pop(); o != "("; o = opStack.pop())
+                            postfix.push(o);
+                    else
+                        throw Error("Invalid expression: unpaired bracket")
+                else if (!p.includes(op))
+                    throw Error("Invalid expression: unknown operator");
+                else {
+                    for (let prevP = p.indexOf(top), curP = p.indexOf(op); curP < prevP; prevP = p.indexOf(opStack[opStack.length - 1]))
+                        postfix.push(opStack.pop());
+                    opStack.push(op);
+                }
+            }
+            if (!opStack.includes('('))
+                while (opStack.length)
+                    postfix.push(opStack.pop());
+            else
+                throw Error("Invalid expression: unpaired bracket");
+            return postfix
+        },
+
+        evaluator: function(model, constants, toNum = true) {
+            let result = [];
+            const operator = (o) => {
+                switch (o) {
+                    case "+":
+                        return "add";
+                    case "-":
+                        return "sub";
+                    case "*":
+                        return "mul";
+                    case "/":
+                        return "div";
+                    case "^":
+                        return "pow";
+                }
+            }
+            for (let token of model) {
+                if (/^[\w.]+$/.test(token))
+                    result.push(token)
+                else {
+                    let a, b, c;
+                    b = result.pop()
+                    a = result.pop()
+                    if (typeof a === "string")
+                        a = constants[a];
+                    if (typeof b === "string")
+                        b = constants[b];
+                    c = Decimal[operator(token)](a, b)
+                    result.push(c);
+                }
+            }
+            if (result.length !== 1)
+                throw Error("Invalid model");
+            else if (toNum && result[0] instanceof Decimal)
+                return result[0].toNumber();
+            else
+                return result[0];
+        },
+
+        makeDeposit: function(amount) {
+            return new Promise(async (resolve, reject) => {
+                try {
+                    let index = this.accMap[myFloID] ? this.accMap[myFloID].length : 0;
+                    //refresh data and update the account net values
+                    await this.refreshData();
+                    //send token to banker floID (using floBlockchain API)
+                    let txid = await this.tokenAPI.sendToken(myPrivKey, amount, "for open-deposit");
+                    let request = {
+                        rtype: "openDeposit",
+                        amount: amount,
+                        txid: txid,
+                        index: index,
+                        sign: floCrypto.signData(this.util.istr + `open#${index}:deposit|${amount}|${txid}`, myPrivKey)
+                    }
+                    //send request to banker (floCloudAPI)
+                    floCloudAPI.sendApplicationData(request, "REQUEST")
+                        .then(result => resolve(result))
+                        .catch(error => reject([error, request]))
+
+                } catch (error) {
+                    reject(error)
+                }
+            })
+        },
+
+        verifyDeposit: function(reqID) {
+            return new Promise(async (resolve, reject) => {
+                let req = this.requests[reqID];
+                try {
+                    //verify the token tx
+                    if (req.rtype !== "openDeposit")
+                        throw ('Invalid request: Request-type is not openDeposit')
+                    if (req.status !== "pending")
+                        throw ("Request already processed");
+                    if (!this.accMap[req.floID])
+                        this.accMap[req.floID] = [];
+                    if (this.checkTxDuplicate(req.txid, req.floID))
+                        throw ("R>Invalid deposit: Token transaction already used")
+                    let tx = await this.tokenAPI.getTx(req.txid);
+                    if (!this.tokenAPI.validateToken(tx, req.floID, floGlobals.adminID, req.amount))
+                        throw ("R>Invalid deposit: Invalid token transaction");
+                    //verify the signature
+                    if (req.index != this.accMap[req.floID].length)
+                        throw (`R>Invalid index (correct index is ${this.accMap[req.floID].length})`);
+                    if (!floCrypto.verifySign(this.util.istr + `open#${req.index}:deposit|${req.amount}|${req.txid}`, req.sign, req.pubKey))
+                        throw ("R>Invalid signature: Re-signing required")
+                    await this.refreshData()
+                    let timestamp = this.util.lastUpdate;
+                    //write deposit details in blockchain
+                    let data = this.dataConstruct(timestamp, req.floID, "open-deposit", req.index, req.sign, req.pubKey, req.amount, req.txid);
+                    let txid = this.writeBankTxData(myPrivKey, data, req.floID);
+                    let response = {
+                        requestID: reqID,
+                        rtype: "openDeposit",
+                        status: "success",
+                        txid: txid
+                    }
+                    req.status = "completed";
+                    compactIDB.writeData("requests", req, reqID);
+                    //send response to client
+                    floCloudAPI.sendApplicationData(response, "RESPONSE", {
+                            receiverID: req.floID
+                        }).then(result => resolve(response))
+                        .catch(error => reject(error))
+
+                } catch (error) {
+                    if (error.message || !error.startsWith('R>'))
+                        reject(error)
+                    else {
+                        let response = {
+                            requestID: reqID,
+                            rtype: "openDeposit",
+                            status: "failed",
+                            reason: error.substring(2)
+                        }
+                        req.status = `failed (${response.reason})`;
+                        compactIDB.writeData("requests", req, reqID);
+                        //send rejected response to client
+                        floCloudAPI.sendApplicationData(response, "RESPONSE", {
+                                receiverID: req.floID
+                            }).then(result => resolve(response))
+                            .catch(error => reject(error))
+                    }
+                }
+            })
+        },
+
+        withdrawDeposit: function(index) {
+            return new Promise(async (resolve, reject) => {
+                try {
+                    //check for validity (ie no loans outstanding)
+                    let details = this.getUserDetails(myFloID)
+                    let acc = details.accounts[index]
+                    if (acc.type !== "deposit")
+                        throw (`Account#${index} is not deposit`)
+                    if (acc.status !== "active")
+                        throw (`Account#${index} is not active`)
+                    if (details.netTotal < acc.netAmt)
+                        throw (`Unable to withdraw deposit: Loan amount exceeds`)
+                    await this.refreshData()
+                    let request = {
+                        rtype: "closeDeposit",
+                        index: index,
+                        sign: floCrypto.signData(this.util.istr + `close#${index}:deposit`, myPrivKey)
+                    }
+                    //send request to banker
+                    floCloudAPI.sendApplicationData(request, "REQUEST")
+                        .then(result => resolve(result))
+                        .catch(error => reject(error))
+                } catch (error) {
+                    reject(error)
+                }
+            })
+        },
+
+        closeDeposit: function(reqID) {
+            return new Promise(async (resolve, reject) => {
+                let req = this.requests[reqID];
+                try {
+                    await this.refreshData()
+                    let timestamp = this.util.lastUpdate;
+                    if (req.rtype !== "closeDeposit")
+                        throw ('Invalid request: Request-type is not closeDeposit')
+                    if (req.status !== "pending")
+                        throw ("Request already processed");
+                    //check for validity (ie no loans outstanding)
+                    let details = this.getUserDetails(req.floID)
+                    let acc = details.accounts[req.index]
+                    if (acc.type !== "deposit")
+                        throw (`R>Account#${req.index} is not deposit`)
+                    if (acc.status !== "active")
+                        throw (`R>Account#${req.index} is not active`)
+                    if (details.netTotal < acc.netAmt)
+                        throw (`R>Unable to close deposit: Loan amount exceeds`)
+                    //check for signature in request
+                    if (floCrypto.verifySign(this.util.istr + `close-deposit#${req.index}`, req.sign, req.pubKey))
+                        throw ("R>Invalid signature: Re-signing required")
+                    //write close-deposit in blockchain 
+                    let data = this.dataConstruct(timestamp, req.floID, "close-deposit", req.index, req.sign, req.pubKey);
+                    let txid = await this.writeBankTxData(myPrivKey, data, req.floID, acc.netAmt);
+                    //send response to client
+                    let response = {
+                        requestID: reqID,
+                        rtype: "closeDeposit",
+                        status: "success",
+                        txid: txid
+                    }
+                    req.status = "completed";
+                    compactIDB.writeData("requests", req, reqID);
+                    floCloudAPI.sendApplicationData(response, "RESPONSE", {
+                            receiverID: req.floID
+                        }).then(result => resolve(response))
+                        .catch(error => reject(error))
+                } catch (error) {
+                    if (error.message || !error.startsWith('R>'))
+                        reject(error)
+                    else {
+                        let response = {
+                            requestID: reqID,
+                            rtype: "closeDeposit",
+                            status: "failed",
+                            reason: error.substring(2)
+                        }
+                        req.status = `failed (${response.reason})`;
+                        compactIDB.writeData("requests", req, reqID);
+                        //send rejected response to client
+                        floCloudAPI.sendApplicationData(response, "RESPONSE", {
+                                receiverID: req.floID
+                            }).then(result => resolve(response))
+                            .catch(error => reject(error))
+                    }
+                }
+            })
+        },
+
+        requestLoan: function(amount) {
+            return new Promise(async (resolve, reject) => {
+                await this.refreshData()
+                let index = this.accMap[myFloID] ? this.accMap[myFloID].length : 0;
+                //check for validity of loan (ie, check if enough deposit is present)
+                let user = this.getUserDetails(myFloID)
+                if (user.netTotal <= amount)
+                    return reject("Deposit insufficient")
+                let request = {
+                    rtype: "openLoan",
+                    index: index,
+                    amount: amount,
+                    sign: floCrypto.signData(this.util.istr + `open#${index}:loan|${amount}`, myPrivKey)
+                }
+                //send request to banker
+                floCloudAPI.sendApplicationData(request, "REQUEST")
                     .then(result => resolve(result))
                     .catch(error => reject(error))
             })
         },
 
-        viewAccount(floID) {
-            let deposits = floGlobals.appObjects.bank["deposits"][floID];
-            let loans = floGlobals.appObjects.bank["loans"][floID];
-            let collaterals = floGlobals.appObjects.bank["collaterals"][floID];
-            return {
-                deposits,
-                loans,
-                collaterals
-            };
-        },
-
-        viewCollateralTypes() {
-            return Object.keys(floGlobals.collaterals)
-        },
-
-        viewRequests(processID = null) {
-            if (!processID)
-                return this.util.requests;
-            else if (Array.isArray(processID)) {
-                let result = {}
-                for (let p of processID)
-                    result[p] = this.util.requests[p];
-                return result
-            } else
-                return this.util.requests[processID]
-        },
-
-        openDeposit_1(amount, period, payMode) {
-            return new Promise((resolve, reject) => {
-                let message = {
-                    request: "openDeposit",
-                    amount: amount,
-                    period: period,
-                    payMode: payMode
-                }
-                floCloudAPI.sendGeneralData(message, "requests")
-                    .then(results => resolve("Open Deposit request sent"))
-                    .catch(error => reject(error))
-            })
-        },
-
-        openDeposit_2(processID, accountDetails) {
-            return new Promise((resolve, reject) => {
-                let r = this.util.requests[processID];
-                debugger;
-                this.banker.processRequest(processID).then(result => {
-                    debugger;
-                    this.sendDirectMessage({
-                            processID,
-                            accountDetails
-                        }, r.requestor, r.pubKey)
-                        .then(results => resolve(
-                            "Deposit process Initiated: Requested deposit amount from client"))
-                        .catch(error => reject(error))
-                }).catch(error => reject(error))
-            })
-        },
-
-        openDeposit_3(processID, paymentRef, bankerFloID, bankerPubKey) {
-            return new Promise((resolve, reject) => {
-                this.sendDirectMessage({
-                        processID,
-                        paymentRef
-                    }, bankerFloID, bankerPubKey)
-                    .then(results => resolve("Deposit paymentRef sent to banker"))
-                    .catch(error => reject(error))
-            })
-        },
-
-        openDeposit_4(processID, interest, paymentRefID) {
-            return new Promise((resolve, reject) => {
-                let r = this.util.requests[processID];
-                this.banker.openNewDeposit(r.requestor, r.amount, r.period, interest, paymentRefID)
-                    .then(result => {
-                        this.sendDirectMessage({
-                                processID,
-                                status: "New Deposit Opened"
-                            }, r.requestor, r.pubKey)
-                            .then(result => resolve("New Deposit opened successfully"))
-                            .catch(error => reject(error))
-                    }).catch(error => reject(error))
-            })
-        },
-
-        closeDeposit_1(index, payMode) {
-            return new Promise((resolve, reject) => {
-                let message = {
-                    request: "closeDeposit",
-                    index: index,
-                    payMode: payMode
-                }
-                floCloudAPI.sendGeneralData(message, "requests")
-                    .then(result => resolve("Close deposit request sent"))
-                    .catch(error => reject(error))
-            })
-        },
-
-        closeDeposit_2(processID) {
-            return new Promise((resolve, reject) => {
-                let r = this.util.requests[processID];
-                this.banker.processRequest(processID).then(result => {
-                    this.sendDirectMessage({
-                            processID,
-                            request: "paymentAccount"
-                        }, r.requestor, r.pubKey)
-                        .then(results => resolve(
-                            "closeDeposit process Initiated: Requested account details from client"
-                        ))
-                        .catch(error => reject(error))
-                }).catch(error => reject(error))
-            })
-        },
-
-        closeDeposit_3(processID, accountDetails, bankerFloID, bankerPubKey) {
-            return new Promise((resolve, reject) => {
-                this.sendDirectMessage({
-                        processID,
-                        accountDetails
-                    }, bankerFloID, bankerPubKey)
-                    .then(results => resolve("Account details sent to banker"))
-                    .catch(error => reject(error))
-            })
-        },
-
-        closeDeposit_4(processID, paymentRef) {
-            return new Promise((resolve, reject) => {
-                let r = this.util.requests[processID];
-                this.banker.closeDeposit(r.requestor, r.index, paymentRef).then(result => {
-                    this.sendDirectMessage({
-                            processID,
-                            text: "Deposit closed"
-                        }, r.requestor, r.pubKey)
-                        .then(result => resolve("New Deposit opened successfully"))
-                        .catch(error => reject(error))
-                }).catch(error => reject(error))
-            })
-        },
-
-        openLoan_1(amount, period, collateral, payMode) {
-            let message = {
-                request: "openLoan",
-                amount: amount,
-                period: period,
-                collateral: collateral,
-                payMode: payMode
-            }
-            return floCloudAPI.sendGeneralData(message, "requests")
-        },
-
-        openLoan_2(processID) {
-            return new Promise((resolve, reject) => {
-                let r = this.util.requests[processID];
-                this.banker.processRequest(processID).then(result => {
-                    this.util.checkCollateralEligibility(r.requestor, r.collateral, r.amount).then(
-                        result => {
-                            this.sendDirectMessage({
-                                    processID,
-                                    request: "paymentAccount"
-                                }, r.requestor, r.pubKey)
-                                .then(results => resolve(
-                                    "openLoan process Initiated: Requested account details from client"
-                                ))
-                                .catch(error => reject(error))
-                        }).catch(error => {
-                        this.sendDirectMessage({
-                                processID,
-                                text: `Loan not sanctioned: ${error}`
-                            }, r.requestor, r.pubKey)
-                            .then(results => resolve(`openLoan rejected: ${error}`))
-                            .catch(error => reject(error))
-                    })
-                }).catch(error => reject(error))
-            })
-        },
-
-        openLoan_3(processID, accountDetails, bankerFloID, bankerPubKey) {
-            return new Promise((resolve, reject) => {
-                this.sendDirectMessage({
-                        processID,
-                        accountDetails
-                    }, bankerFloID, bankerPubKey)
-                    .then(results => resolve("Account details sent to banker"))
-                    .catch(error => reject(error))
-            })
-        },
-
-        openLoan_4(processID, interest, paymentRef) {
-            return new Promise((resolve, reject) => {
-                let r = this.util.requests[processID];
-                this.banker.openNewLoan(r.requestor, r.amount, r.period, interest, r.collateral, paymentRef)
-                    .then(result => {
-                        this.sendDirectMessage({
-                                processID,
-                                text: "Loan opened"
-                            }, r.requestor, r.pubKey)
-                            .then(result => resolve("New Deposit opened successfully"))
-                            .catch(error => reject(error))
-                    }).catch(error => reject(error))
-            })
-        },
-
-        closeLoan_1(index, payMode) {
-            return new Promise((resolve, reject) => {
-                let message = {
-                    request: "closeLoan",
-                    index: index,
-                    payMode: payMode
-                }
-                floCloudAPI.sendGeneralData(message, "requests")
-                    .then(result => resolve("Close loan request sent"))
-                    .catch(error => reject(error))
-            })
-        },
-
-        closeLoan_2(processID, accountDetails) {
-            return new Promise((resolve, reject) => {
-                let r = this.util.requests[processID];
-                this.banker.processRequest(processID).then(result => {
-                    this.sendDirectMessage({
-                            processID,
-                            accountDetails
-                        }, r.requestor, r.pubKey)
-                        .then(results => resolve(
-                            "closeLoan process Initiated: Requested loan repay from client"))
-                        .catch(error => reject(error))
-                }).catch(error => reject(error))
-            })
-        },
-
-        closeLoan_3(processID, paymentRef, bankerFloID, bankerPubKey) {
-            return new Promise((resolve, reject) => {
-                this.sendDirectMessage({
-                        processID,
-                        paymentRef
-                    }, bankerFloID, bankerPubKey)
-                    .then(results => resolve("Loan repay paymentRef sent to banker"))
-                    .catch(error => reject(error))
-            })
-        },
-
-        closeLoan_4(processID, paymentRef) {
-            return new Promise((resolve, reject) => {
-                let r = this.util.requests[processID];
-                this.banker.closeLoan(r.requestor, r.index, paymentRef).then(result => {
-                    this.sendDirectMessage({
-                            processID,
-                            text: "Deposit closed"
-                        }, r.requestor, r.pubKey)
-                        .then(result => resolve("New Deposit opened successfully"))
-                        .catch(error => reject(error))
-                }).catch(error => reject(error))
-            })
-        },
-
-        buyCollateral_1(amount, collateralType, payMode) {
-            return new Promise((resolve, reject) => {
-                let message = {
-                    request: "buyCollateral",
-                    amount: amount,
-                    collateralType: collateralType,
-                    payMode: payMode
-                }
-                floCloudAPI.sendGeneralData(message, "requests")
-                    .then(result => resolve("Buy collateral request sent"))
-                    .catch(error => reject(error))
-            })
-        },
-
-        buyCollateral_2(processID, accountDetails) {
-            return new Promise((resolve, reject) => {
-                let r = this.util.requests[processID];
-                this.banker.processRequest(processID).then(result => {
-                    this.sendDirectMessage({
-                            processID,
-                            accountDetails
-                        }, r.requestor, r.pubKey)
-                        .then(results => resolve(
-                            "buyCollateral process Initiated: Requested amount from client"))
-                        .catch(error => reject(error))
-                }).catch(error => reject(error))
-            })
-        },
-
-        buyCollateral_3(processID, paymentRef, bankerFloID, bankerPubKey) {
-            return new Promise((resolve, reject) => {
-                this.sendDirectMessage({
-                        processID,
-                        paymentRef
-                    }, bankerFloID, bankerPubKey)
-                    .then(results => resolve("Collateral amount paymentRef sent to banker"))
-                    .catch(error => reject(error))
-            })
-        },
-
-        buyCollateral_4(processID, paymentRefID, units, details, comment) {
-            return new Promise((resolve, reject) => {
-                let r = this.util.requests[processID];
-                this.banker.openCollateral(r.requestor, paymentRefID, r.collateralType, units, details,
-                        comment)
-                    .then(result => {
-                        this.sendDirectMessage({
-                                processID,
-                                status: "Collateral brought"
-                            }, r.requestor, r.pubKey)
-                            .then(result => resolve("New Collateral brought successfully"))
-                            .catch(error => reject(error))
-                    }).catch(error => reject(error))
-            })
-        },
-
-        sellCollateral_1(index, payMode) {
-            return new Promise((resolve, reject) => {
-                let message = {
-                    request: "sellCollateral",
-                    index: index,
-                    payMode: payMode
-                }
-                floCloudAPI.sendGeneralData(message, "requests")
-                    .then(result => resolve("Sell Collateral request sent"))
-                    .catch(error => reject(error))
-            })
-        },
-
-        sellCollateral_2(processID) {
-            return new Promise((resolve, reject) => {
-                let r = this.util.requests[processID];
-                this.banker.processRequest(processID).then(result => {
-                    this.sendDirectMessage({
-                            processID,
-                            request: "paymentAccount"
-                        }, r.requestor, r.pubKey)
-                        .then(results => resolve(
-                            "sellCollateral process Initiated: Requested account details from client"
-                        ))
-                        .catch(error => reject(error))
-                }).catch(error => reject(error))
-            })
-        },
-
-        sellCollateral_3(processID, accountDetails, bankerFloID, bankerPubKey) {
-            return new Promise((resolve, reject) => {
-                this.sendDirectMessage({
-                        processID,
-                        accountDetails
-                    }, bankerFloID, bankerPubKey)
-                    .then(results => resolve("Account details sent to banker"))
-                    .catch(error => reject(error))
-            })
-        },
-
-        sellCollateral_4(processID, paymentRef) {
-            return new Promise((resolve, reject) => {
-                let r = this.util.requests[processID];
-                this.banker.closeCollateral(r.requestor, r.index, paymentRef).then(result => {
-                    this.sendDirectMessage({
-                            processID,
-                            text: "Collateral sold"
-                        }, r.requestor, r.pubKey)
-                        .then(result => resolve("New Deposit opened successfully"))
-                        .catch(error => reject(error))
-                }).catch(error => reject(error))
-            })
-        },
-
-        checkCollateralEligibility(floID, collateralIndex, loanAmount) {
-            return new Promise((resolve, reject) => {
-                let col;
+        sendLoan: function(reqID) {
+            return new Promise(async (resolve, reject) => {
+                let req = this.requests[reqID];
                 try {
-                    col = floGlobals.appObjects["collaterals"][floID][collateralIndex];
+                    await this.refreshData()
+                    let timestamp = this.util.lastUpdate;
+                    if (req.rtype !== "openLoan")
+                        throw ('Invalid request: Request-type is not openLoan');
+                    if (req.status !== "pending")
+                        throw ("Request already processed");
+                    //verify the signature
+                    if (req.index != this.accMap[req.floID].length)
+                        throw (`R>Invalid index (correct index is ${this.accMap[req.floID].length})`);
+                    if (!floCrypto.verifySign(this.util.istr + `open#${req.index}:loan|${req.amount}`, req.sign, req.pubKey))
+                        throw ("R>Invalid signature: Re-signing required");
+                    //check for validity of loan (ie, check if enough deposit is present)
+                    let user = this.getUserDetails(req.floID)
+                    if (user.netTotal <= req.amount)
+                        return reject("R>Deposit insufficient");
+                    let data = this.dataConstruct(timestamp, req.floID, "open-loan", req.index, req.sign, req.pubKey, req.amount);
+                    let txid = await this.writeBankTxData(myPrivKey, data, req.floID, req.amount)
+                    let response = {
+                        requestID: reqID,
+                        rtype: "openLoan",
+                        status: "success",
+                        txid: txid
+                    }
+                    req.status = "completed";
+                    compactIDB.writeData("requests", req, reqID);
+                    floCloudAPI.sendApplicationData(response, "RESPONSE", {
+                            receiverID: req.floID
+                        }).then(result => resolve(result))
+                        .catch(error => reject(error))
                 } catch (error) {
-                    return reject("Account doesnot own any collateral")
-                }
-                if (!col)
-                    return reject("Collateral Not Found!")
-                else if (col.status !== "ACTIVE")
-                    return reject(`Collateral is not Active! (current status: ${col.status})`)
-                else if (col.loanRefs && col.loanRefs.length) {
-                    let loans = col.loanRefs.map(i => floGlobals.appObjects.bank["loans"][floID][
-                        i
-                    ])
-                    let totalLoanAmt = 0
-                    loans.forEach(l => totalLoanAmt += l.amount)
-                    let netVal = this.util.unitValues[col.type];
-                    let loanThreshold = floGlobals.settings["loanRatio"] * col.units * netVal;
-                    if (totalLoanAmt >= loanThreshold)
-                        return reject("Collateral threshold already exceeded")
-                    let tmpAmt = loanAmount + totalLoanAmt;
-                    if (tmpAmt >= loanThreshold)
-                        return reject("Collateral doesnot have enough NET value")
-                    resolve("Collateral eligible for loan")
-                } else
-                    resolve("Collateral eligible for loan")
-            })
-        },
-
-
-        isCollateralOverflow(floID, index) {
-            if (!col.loanRefs.length)
-                return false
-            let col = floGlobals.appObjects["collaterals"][floID][index];
-            let loanThreshold = floGlobals.settings["loanRatio"] * col.units * this.util.unitValues[col.type];
-            let loans = col.loanRefs.map(i => floGlobals.appObjects.bank["loans"][floID][i])
-            let totalLoanAmt = 0;
-            loans.forEach(l => totalLoanAmt += l.amount)
-            if (totalLoanAmt >= loanThreshold)
-                return true;
-            else
-                return false;
-        },
-
-        viewCollateralOverflows(floIDs = null) {
-            if (!floIDs)
-                floIDs = Object.keys(floGlobals.appObjects["collaterals"])
-            else if (floCrypto.validateAddr(floIDs))
-                floIDs = [floIDs]
-            else if (!Array.isArray(floIDs))
-                throw Error("Invalid parameters: Parameters must be floID or array of floIDs");
-            let overflows = {}
-            floIDs.forEach(f => {
-                if (f in floGlobals.appObjects["collaterals"]) {
-                    overflows[f] = []
-                    for (let i in floGlobals.appObjects["collaterals"][f]) {
-                        if (this.isCollateralOverflow(f, i))
-                            overflows[f].push(floGlobals.appObjects["collaterals"][f][i])
-                    }
-                    if (!overflows[f].length)
-                        delete overflows[f]
-                }
-            })
-            return overflows;
-        },
-
-        //Banker only functions (subAdmins only)
-        banker: {
-
-            processRequest(processID) {
-                return new Promise((resolve, reject) => {
-                    floCloudAPI.requestObjectData("bank").then(result => {
-                        if (processID in floGlobals.appObjects.bank["process"])
-                            reject("Request already in process")
-                        else {
-                            floGlobals.appObjects.bank["process"][processID] = myFloID
-                            floCloudAPI.updateObjectData("bank")
-                                .then(result => resolve(result))
-                                .catch(error => reject(error))
+                    if (error.message || !error.startsWith('R>'))
+                        reject(error)
+                    else {
+                        let response = {
+                            requestID: reqID,
+                            rtype: "openLoan",
+                            status: "failed",
+                            reason: error.substring(2)
                         }
-                    })
-                })
-            },
-
-            openNewDeposit(floID, amount, period, interest, paymentRefID) {
-                let depositDetails = {
-                    amount: amount,
-                    period: period,
-                    interest: interest,
-                    opening: {
-                        paymentRefID: paymentRefID,
-                        timestamp: Date.now()
-                    },
-                    closing: {
-                        paymentRefID: null,
-                        timestamp: null
-                    },
-                    status: "ACTIVE"
-                }
-                if (!Array.isArray(floGlobals.appObjects.bank["deposits"][floID]))
-                    floGlobals.appObjects.bank["deposits"][floID] = []
-                floGlobals.appObjects.bank["deposits"][floID].push(depositDetails)
-                return floCloudAPI.updateObjectData("bank")
-            },
-
-            closeDeposit(floID, index, paymentRefID) {
-                floGlobals.appObjects.bank["deposits"][floID][index].closing.paymentRefID = paymentRefID;
-                floGlobals.appObjects.bank["deposits"][floID][index].closing.timestamp = Date.now();
-                floGlobals.appObjects.bank["deposits"][floID][index].status = "CLOSED";
-                return floCloudAPI.updateObjectData("bank")
-            },
-
-            openNewLoan(floID, amount, period, interest, collateralIndex, paymentRefID) {
-                let loanDetails = {
-                    amount: amount,
-                    period: period,
-                    interest: interest,
-                    opening: {
-                        paymentRefID: paymentRefID,
-                        timestamp: Date.now()
-                    },
-                    collateral: collateralIndex,
-                    closing: {
-                        paymentRefID: null,
-                        timestamp: null
-                    },
-                    status: "ACTIVE"
-                }
-                if (!Array.isArray(floGlobals.appObjects.bank["loans"][floID]))
-                    floGlobals.appObjects.bank["loans"][floID] = []
-                floGlobals.appObjects.bank["loans"][floID].push(loanDetails)
-                return floCloudAPI.updateObjectData("bank")
-            },
-
-            closeLoan(floID, index, paymentRefID) {
-                floGlobals.appObjects.bank["loans"][floID][index].closing.paymentRefID = paymentRefID;
-                floGlobals.appObjects.bank["loans"][floID][index].closing.timestamp = Date.now();
-                floGlobals.appObjects.bank["loans"][floID][index].status = "CLOSED";
-                return floCloudAPI.updateObjectData("bank")
-            },
-
-            openCollateral(floID, paymentRefID, type, units, details, comment) {
-                let newCollateral = {
-                    type: type,
-                    units: units,
-                    details: details,
-                    opening: {
-                        paymentRefID: paymentRefID,
-                        timestamp: Date.now()
-                    },
-                    closing: {
-                        paymentRefID: null,
-                        timestamp: null
-                    },
-                    status: "ACTIVE",
-                    loanRefs: [],
-                    comment: comment
-                }
-                if (!Array.isArray(floGlobals.appObjects.bank["collaterals"][floID]))
-                    floGlobals.appObjects.bank["collaterals"][floID] = []
-                floGlobals.appObjects.bank["collaterals"][floID].push(depositDetails)
-                return floCloudAPI.updateObjectData("bank")
-            },
-
-            setCollateralStatus(floID, index, status) {
-                //status values = "ACTIVE" | "LOCKED"
-                floGlobals.appObjects.bank["collaterals"][floID][index].status = status;
-                return floCloudAPI.updateObjectData("bank")
-            },
-
-            closeCollateral(floID, index, paymentRef) {
-                floGlobals.appObjects.bank["collaterals"][floID][index].closing.paymentRefID = paymentRefID;
-                floGlobals.appObjects.bank["collaterals"][floID][index].closing.timestamp = Date.now();
-                floGlobals.appObjects.bank["collaterals"][floID][index].status = "CLOSED";
-                return floCloudAPI.updateObjectData("bank")
-            }
-        },
-
-        manageCollateralList(adminPrivKey, addCollateral, removeCollateral) {
-            return new Promise((resolve, reject) => {
-                if (!Object.keys(addCollateral).length) addCollateral = undefined;
-                if (!Object.keys(removeCollateral).length) removeCollateral = undefined;
-                if (!addCollateral && !removeCollateral)
-                    return reject("collateral manage list is empty")
-                var floData = {
-                    [floGlobals.application]: {
-                        addCollateral: addCollateral,
-                        removeCollateral: removeCollateral,
+                        req.status = `failed (${response.reason})`;
+                        compactIDB.writeData("requests", req, reqID);
+                        //send rejected response to client
+                        floCloudAPI.sendApplicationData(response, "RESPONSE", {
+                                receiverID: req.floID
+                            }).then(result => resolve(response))
+                            .catch(error => reject(error))
                     }
                 }
-                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 Collateral List', result]))
-                    .catch(error => reject(error))
             })
         },
+
+        repayLoan: function(index) {
+            return new Promise(async (resolve, reject) => {
+                try {
+                    this.refreshData();
+                    let details = this.getUserDetails(myFloID)
+                    let acc = details.accounts[index]
+                    if (acc.type !== "loan")
+                        throw (`Account#${index} is not loan`)
+                    if (acc.status !== "active")
+                        throw (`Account#${index} is not active`)
+                    //send token to banker floID (using floBlockchain API)
+                    let txid = await this.tokenAPI.sendToken(myPrivKey, acc.netAmt * this.util.delta, "for close-loan");
+                    //send request to banker (floCloudAPI)
+                    let request = {
+                        rtype: "closeLoan",
+                        index: index,
+                        txid: txid,
+                        sign: floCrypto.signData(this.util.istr + `close#${index}:loan|${txid}`, myPrivKey)
+                    }
+                    floCloudAPI.sendApplicationData(request, "REQUEST")
+                        .then(result => resolve(result))
+                        .catch(error => reject(error))
+                } catch (error) {
+                    reject(error)
+                }
+            })
+        },
+
+        closeLoan: function(reqID) {
+            return new Promise(async (resolve, reject) => {
+                let req = this.requests[reqID];
+                try {
+                    if (req.rtype !== "closeLoan")
+                        throw ('Invalid request: Request-type is not closeLoan');
+                    if (req.status !== "pending")
+                        throw ("Request already processed");
+                    //verify signature
+                    if (!floCrypto.verifySign(this.util.istr + `close#${req.index}:loan|${req.txid}`, req.sign, req.pubKey))
+                        throw ("R>Invalid signature: Re-signing required");
+                    //verify token tx
+                    if (!this.accMap[req.floID])
+                        this.accMap[req.floID] = [];
+                    if (this.checkTxDuplicate(req.txid, req.floID))
+                        throw ("R>Invalid deposit: Token transaction already used")
+                    let tx = await this.tokenAPI.getTx(req.txid);
+                    await this.refreshData()
+                    let acc = this.getAccount(req.floID, req.index);
+                    if (acc.status !== "active")
+                        throw ("Account already closed");
+                    if (tx.amount < acc.netAmt)
+                        throw ("R>Invalid request: Token amount insufficient");
+                    if (!this.tokenAPI.validateToken(tx, req.floID, floGlobals.adminID))
+                        throw ("R>Invalid request: Invalid token transaction")
+                    let timestamp = this.util.lastUpdate;
+                    let change = tx.amount - acc.netAmt;
+                    //close loan via blockchain
+                    let data = this.dataConstruct(timestamp, req.floID, "close-loan", req.index, req.sign, req.pubKey, null, req.txid);
+                    let txid = await this.writeBankTxData(myPrivKey, data, req.floID, change)
+                    let response = {
+                        requestID: reqID,
+                        rtype: "closeLoan",
+                        status: "success",
+                        txid: txid
+                    }
+                    req.status = "completed";
+                    compactIDB.writeData("requests", req, reqID);
+                    floCloudAPI.sendApplicationData(response, "RESPONSE", {
+                            receiverID: req.floID
+                        }).then(result => resolve(result))
+                        .catch(error => reject(error))
+                } catch (error) {
+                    if (error.message || !error.startsWith('R>'))
+                        reject(error)
+                    else {
+                        let response = {
+                            requestID: reqID,
+                            rtype: "closeLoan",
+                            status: "failed",
+                            reason: error.substring(2)
+                        }
+                        req.status = `failed (${response.reason})`;
+                        compactIDB.writeData("requests", req, reqID);
+                        //send rejected response to client
+                        floCloudAPI.sendApplicationData(response, "RESPONSE", {
+                                receiverID: req.floID
+                            }).then(result => resolve(response))
+                            .catch(error => reject(error))
+                    }
+                }
+            })
+        },
+
+        viewAllRequests: function(floID = null) {
+            let requests = this.requests
+            if (floID) {
+                let result = {}
+                for (let r in requests)
+                    if (requests[r].floID === floID)
+                        result[r] = requests[r];
+                return result;
+            } else
+                return requests;
+        },
+
+        viewAllResponses: function() {
+            return this.responses;
+        }
     }
 </script>
 </body>
