From 4564f99752722e6e6929caaadc2a071258463643 Mon Sep 17 00:00:00 2001
From: tripathyr <rohit.tripathy@gmail.com>
Date: Mon, 27 Dec 2021 15:18:49 +0530
Subject: [PATCH] Updated standard operations to v2.1.0e

---
 Layouts/boxes layout/index.html | 4761 ++++++++++++++++---------------
 1 file changed, 2404 insertions(+), 2357 deletions(-)

diff --git a/Layouts/boxes layout/index.html b/Layouts/boxes layout/index.html
index 8a05693..19ccca7 100644
--- a/Layouts/boxes layout/index.html	
+++ b/Layouts/boxes layout/index.html	
@@ -7028,439 +7028,462 @@
     </script>
     
     <script id="floCrypto" version="2.0.1">
-        /* FLO Crypto Operators*/
-        const floCrypto = {
-    
-            util: {
-                p: BigInteger("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F", 16),
-    
-                ecparams: EllipticCurve.getSECCurveByName("secp256k1"),
-    
-                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) {
-                    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) {
-                    const p = this.p;
-                    // Fetch x from compressedPublicKey
-                    let pubKeyBytes = Crypto.util.hexToBytes(compressedPublicKey);
-                    const prefix = pubKeyBytes.shift() // remove prefix
-                    let prefix_modulus = prefix % 2;
-                    pubKeyBytes.unshift(0) // add prefix 0
-                    let x = new BigInteger(pubKeyBytes)
-                    let xDecimalValue = x.toString()
-                    // Fetch y
-                    let y = this.calculateY(x);
-                    let yDecimalValue = y.toString();
-                    // verify y value
-                    let resultBigInt = y.mod(BigInteger("2"));
-                    let check = resultBigInt.toString() % 2;
-                    if (prefix_modulus !== check)
-                        yDecimalValue = y.negate().mod(p).toString();
-                    return {
-                        x: xDecimalValue,
-                        y: yDecimalValue
-                    };
-                },
-    
-                getSenderPublicKeyString: function() {
-                    privateKey = ellipticCurveEncryption.senderRandom();
-                    senderPublicKeyString = ellipticCurveEncryption.senderPublicString(privateKey);
-                    return {
-                        privateKey: privateKey,
-                        senderPublicKeyString: senderPublicKeyString
-                    }
-                },
-    
-                deriveSharedKeySender: function(receiverCompressedPublicKey, senderPrivateKey) {
-                    let receiverPublicKeyString = this.getUncompressedPublicKey(receiverCompressedPublicKey);
-                    var senderDerivedKey = ellipticCurveEncryption.senderSharedKeyDerivation(
-                        receiverPublicKeyString.x, receiverPublicKeyString.y, senderPrivateKey);
-                    return senderDerivedKey;
-                },
-    
-                deriveReceiverSharedKey: function(senderPublicKeyString, receiverPrivateKey) {
-                    return ellipticCurveEncryption.receiverSharedKeyDerivation(
-                        senderPublicKeyString.XValuePublicString, senderPublicKeyString.YValuePublicString, receiverPrivateKey);
-                },
-    
-                getReceiverPublicKeyString: function(privateKey) {
-                    return ellipticCurveEncryption.receiverPublicString(privateKey);
-                },
-    
-                deriveSharedKeyReceiver: function(senderPublicKeyString, receiverPrivateKey) {
-                    return ellipticCurveEncryption.receiverSharedKeyDerivation(
-                        senderPublicKeyString.XValuePublicString, senderPublicKeyString.YValuePublicString, receiverPrivateKey);
-                },
-    
-                wifToDecimal: function(pk_wif, isPubKeyCompressed = false) {
-                    let pk = Bitcoin.Base58.decode(pk_wif)
-                    pk.shift()
-                    pk.splice(-4, 4)
-                    //If the private key corresponded to a compressed public key, also drop the last byte (it should be 0x01).
-                    if (isPubKeyCompressed == true) pk.pop()
-                    pk.unshift(0)
-                    privateKeyDecimal = BigInteger(pk).toString()
-                    privateKeyHex = Crypto.util.bytesToHex(pk)
-                    return {
-                        privateKeyDecimal: privateKeyDecimal,
-                        privateKeyHex: privateKeyHex
-                    }
-                }
+    /* FLO Crypto Operators*/
+    const floCrypto = {
+
+        util: {
+            p: BigInteger("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F", 16),
+
+            ecparams: EllipticCurve.getSECCurveByName("secp256k1"),
+
+            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"))
             },
-    
-            //generate a random Interger within range
-            randInt: function(min, max) {
-                min = Math.ceil(min);
-                max = Math.floor(max);
-                return Math.floor(Math.random() * (max - min + 1)) + min;
+
+            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)
             },
-    
-            //generate a random String within length (options : alphaNumeric chars only)
-            randString: function(length, alphaNumeric = true) {
-                var result = '';
-                if (alphaNumeric)
-                    var characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-                else
-                    var characters =
-                        'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_+-./*?@#&$<>=[]{}():';
-                for (var i = 0; i < length; i++)
-                    result += characters.charAt(Math.floor(Math.random() * characters.length));
-                return result;
-            },
-    
-            //Encrypt Data using public-key
-            encryptData: function(data, receiverCompressedPublicKey) {
-                var senderECKeyData = this.util.getSenderPublicKeyString();
-                var senderDerivedKey = this.util.deriveSharedKeySender(receiverCompressedPublicKey, senderECKeyData
-                    .privateKey);
-                let senderKey = senderDerivedKey.XValue + senderDerivedKey.YValue;
-                let secret = Crypto.AES.encrypt(data, senderKey);
+            getUncompressedPublicKey: function(compressedPublicKey) {
+                const p = this.p;
+                // Fetch x from compressedPublicKey
+                let pubKeyBytes = Crypto.util.hexToBytes(compressedPublicKey);
+                const prefix = pubKeyBytes.shift() // remove prefix
+                let prefix_modulus = prefix % 2;
+                pubKeyBytes.unshift(0) // add prefix 0
+                let x = new BigInteger(pubKeyBytes)
+                let xDecimalValue = x.toString()
+                // Fetch y
+                let y = this.calculateY(x);
+                let yDecimalValue = y.toString();
+                // verify y value
+                let resultBigInt = y.mod(BigInteger("2"));
+                let check = resultBigInt.toString() % 2;
+                if (prefix_modulus !== check)
+                    yDecimalValue = y.negate().mod(p).toString();
                 return {
-                    secret: secret,
-                    senderPublicKeyString: senderECKeyData.senderPublicKeyString
+                    x: xDecimalValue,
+                    y: yDecimalValue
                 };
             },
-    
-            //Decrypt Data using private-key
-            decryptData: function(data, myPrivateKey) {
-                var receiverECKeyData = {};
-                if (typeof myPrivateKey !== "string") throw new Error("No private key found.");
-    
-                let privateKey = this.util.wifToDecimal(myPrivateKey, true);
-                if (typeof privateKey.privateKeyDecimal !== "string") throw new Error(
-                    "Failed to detremine your private key.");
-                receiverECKeyData.privateKey = privateKey.privateKeyDecimal;
-    
-                var receiverDerivedKey = this.util.deriveReceiverSharedKey(data.senderPublicKeyString,
-                    receiverECKeyData
-                    .privateKey);
-    
-                let receiverKey = receiverDerivedKey.XValue + receiverDerivedKey.YValue;
-                let decryptMsg = Crypto.AES.decrypt(data.secret, receiverKey);
-                return decryptMsg;
-            },
-    
-            //Sign data using private-key
-            signData: function(data, privateKeyHex) {
-                var key = new Bitcoin.ECKey(privateKeyHex);
-                key.setCompressed(true);
-    
-                var privateKeyArr = key.getBitcoinPrivateKeyByteArray();
-                privateKey = BigInteger.fromByteArrayUnsigned(privateKeyArr);
-                var messageHash = Crypto.SHA256(data);
-    
-                var messageHashBigInteger = new BigInteger(messageHash);
-                var messageSign = Bitcoin.ECDSA.sign(messageHashBigInteger, key.priv);
-    
-                var sighex = Crypto.util.bytesToHex(messageSign);
-                return sighex;
-            },
-    
-            //Verify signatue of the data using public-key
-            verifySign: function(data, signatureHex, publicKeyHex) {
-                var msgHash = Crypto.SHA256(data);
-                var messageHashBigInteger = new BigInteger(msgHash);
-    
-                var sigBytes = Crypto.util.hexToBytes(signatureHex);
-                var signature = Bitcoin.ECDSA.parseSig(sigBytes);
-    
-                var publicKeyPoint = this.util.ecparams.getCurve().decodePointHex(publicKeyHex);
-    
-                var verify = Bitcoin.ECDSA.verifyRaw(messageHashBigInteger, signature.r, signature.s,
-                    publicKeyPoint);
-                return verify;
-            },
-    
-            //Generates a new flo ID and returns private-key, public-key and floID
-            generateNewID: function() {
-                try {
-                    var key = new Bitcoin.ECKey(false);
-                    key.setCompressed(true);
-                    return {
-                        floID: key.getBitcoinAddress(),
-                        pubKey: key.getPubKeyHex(),
-                        privKey: key.getBitcoinWalletImportFormat()
-                    }
-                } catch (e) {
-                    console.error(e);
+
+            getSenderPublicKeyString: function() {
+                privateKey = ellipticCurveEncryption.senderRandom();
+                senderPublicKeyString = ellipticCurveEncryption.senderPublicString(privateKey);
+                return {
+                    privateKey: privateKey,
+                    senderPublicKeyString: senderPublicKeyString
                 }
             },
-    
-            //Returns public-key from private-key
-            getPubKeyHex: function(privateKeyHex) {
-                if (!privateKeyHex)
-                    return null;
+
+            deriveSharedKeySender: function(receiverCompressedPublicKey, senderPrivateKey) {
+                let receiverPublicKeyString = this.getUncompressedPublicKey(receiverCompressedPublicKey);
+                var senderDerivedKey = ellipticCurveEncryption.senderSharedKeyDerivation(
+                    receiverPublicKeyString.x, receiverPublicKeyString.y, senderPrivateKey);
+                return senderDerivedKey;
+            },
+
+            deriveReceiverSharedKey: function(senderPublicKeyString, receiverPrivateKey) {
+                return ellipticCurveEncryption.receiverSharedKeyDerivation(
+                    senderPublicKeyString.XValuePublicString, senderPublicKeyString.YValuePublicString, receiverPrivateKey);
+            },
+
+            getReceiverPublicKeyString: function(privateKey) {
+                return ellipticCurveEncryption.receiverPublicString(privateKey);
+            },
+
+            deriveSharedKeyReceiver: function(senderPublicKeyString, receiverPrivateKey) {
+                return ellipticCurveEncryption.receiverSharedKeyDerivation(
+                    senderPublicKeyString.XValuePublicString, senderPublicKeyString.YValuePublicString, receiverPrivateKey);
+            },
+
+            wifToDecimal: function(pk_wif, isPubKeyCompressed = false) {
+                let pk = Bitcoin.Base58.decode(pk_wif)
+                pk.shift()
+                pk.splice(-4, 4)
+                //If the private key corresponded to a compressed public key, also drop the last byte (it should be 0x01).
+                if (isPubKeyCompressed == true) pk.pop()
+                pk.unshift(0)
+                privateKeyDecimal = BigInteger(pk).toString()
+                privateKeyHex = Crypto.util.bytesToHex(pk)
+                return {
+                    privateKeyDecimal: privateKeyDecimal,
+                    privateKeyHex: privateKeyHex
+                }
+            }
+        },
+
+        //generate a random Interger within range
+        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 = true) {
+            var result = '';
+            if (alphaNumeric)
+                var characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+            else
+                var characters =
+                    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_+-./*?@#&$<>=[]{}():';
+            for (var i = 0; i < length; i++)
+                result += characters.charAt(Math.floor(Math.random() * characters.length));
+            return result;
+        },
+
+        //Encrypt Data using public-key
+        encryptData: function(data, receiverCompressedPublicKey) {
+            var senderECKeyData = this.util.getSenderPublicKeyString();
+            var senderDerivedKey = this.util.deriveSharedKeySender(receiverCompressedPublicKey, senderECKeyData
+                .privateKey);
+            let senderKey = senderDerivedKey.XValue + senderDerivedKey.YValue;
+            let secret = Crypto.AES.encrypt(data, senderKey);
+            return {
+                secret: secret,
+                senderPublicKeyString: senderECKeyData.senderPublicKeyString
+            };
+        },
+
+        //Decrypt Data using private-key
+        decryptData: function(data, myPrivateKey) {
+            var receiverECKeyData = {};
+            if (typeof myPrivateKey !== "string") throw new Error("No private key found.");
+
+            let privateKey = this.util.wifToDecimal(myPrivateKey, true);
+            if (typeof privateKey.privateKeyDecimal !== "string") throw new Error(
+                "Failed to detremine your private key.");
+            receiverECKeyData.privateKey = privateKey.privateKeyDecimal;
+
+            var receiverDerivedKey = this.util.deriveReceiverSharedKey(data.senderPublicKeyString,
+                receiverECKeyData
+                .privateKey);
+
+            let receiverKey = receiverDerivedKey.XValue + receiverDerivedKey.YValue;
+            let decryptMsg = Crypto.AES.decrypt(data.secret, receiverKey);
+            return decryptMsg;
+        },
+
+        //Sign data using private-key
+        signData: function(data, privateKeyHex) {
+            var key = new Bitcoin.ECKey(privateKeyHex);
+            key.setCompressed(true);
+
+            var privateKeyArr = key.getBitcoinPrivateKeyByteArray();
+            privateKey = BigInteger.fromByteArrayUnsigned(privateKeyArr);
+            var messageHash = Crypto.SHA256(data);
+
+            var messageHashBigInteger = new BigInteger(messageHash);
+            var messageSign = Bitcoin.ECDSA.sign(messageHashBigInteger, key.priv);
+
+            var sighex = Crypto.util.bytesToHex(messageSign);
+            return sighex;
+        },
+
+        //Verify signatue of the data using public-key
+        verifySign: function(data, signatureHex, publicKeyHex) {
+            var msgHash = Crypto.SHA256(data);
+            var messageHashBigInteger = new BigInteger(msgHash);
+
+            var sigBytes = Crypto.util.hexToBytes(signatureHex);
+            var signature = Bitcoin.ECDSA.parseSig(sigBytes);
+
+            var publicKeyPoint = this.util.ecparams.getCurve().decodePointHex(publicKeyHex);
+
+            var verify = Bitcoin.ECDSA.verifyRaw(messageHashBigInteger, signature.r, signature.s,
+                publicKeyPoint);
+            return verify;
+        },
+
+        //Generates a new flo ID and returns private-key, public-key and floID
+        generateNewID: function() {
+            try {
+                var key = new Bitcoin.ECKey(false);
+                key.setCompressed(true);
+                return {
+                    floID: key.getBitcoinAddress(),
+                    pubKey: key.getPubKeyHex(),
+                    privKey: key.getBitcoinWalletImportFormat()
+                }
+            } catch (e) {
+                console.error(e);
+            }
+        },
+
+        //Returns public-key from private-key
+        getPubKeyHex: function(privateKeyHex) {
+            if (!privateKeyHex)
+                return null;
+            var key = new Bitcoin.ECKey(privateKeyHex);
+            if (key.priv == null)
+                return null;
+            key.setCompressed(true);
+            return key.getPubKeyHex();
+        },
+
+        //Returns flo-ID from public-key or private-key
+        getFloID: function(keyHex) {
+            if (!keyHex)
+                return null;
+            try {
+                var key = new Bitcoin.ECKey(keyHex);
+                if (key.priv == null)
+                    key.setPub(keyHex);
+                return key.getBitcoinAddress();
+            } catch (e) {
+                return null;
+            }
+        },
+
+        //Verify the private-key for the given public-key or flo-ID
+        verifyPrivKey: function(privateKeyHex, pubKey_floID, isfloID = true) {
+            if (!privateKeyHex || !pubKey_floID)
+                return false;
+            try {
                 var key = new Bitcoin.ECKey(privateKeyHex);
                 if (key.priv == null)
-                    return null;
+                    return false;
                 key.setCompressed(true);
-                return key.getPubKeyHex();
-            },
-    
-            //Returns flo-ID from public-key or private-key
-            getFloID: function(keyHex) {
-                if (!keyHex)
-                    return null;
-                try {
-                    var key = new Bitcoin.ECKey(keyHex);
-                    if (key.priv == null)
-                        key.setPub(keyHex);
-                    return key.getBitcoinAddress();
-                } catch (e) {
-                    return null;
-                }
-            },
-    
-            //Verify the private-key for the given public-key or flo-ID
-            verifyPrivKey: function(privateKeyHex, pubKey_floID, isfloID = true) {
-                if (!privateKeyHex || !pubKey_floID)
-                    return false;
-                try {
-                    var key = new Bitcoin.ECKey(privateKeyHex);
-                    if (key.priv == null)
-                        return false;
-                    key.setCompressed(true);
-                    if (isfloID && pubKey_floID == key.getBitcoinAddress())
-                        return true;
-                    else if (!isfloID && pubKey_floID == key.getPubKeyHex())
-                        return true;
-                    else
-                        return false;
-                } catch (e) {
-                    console.error(e);
-                }
-            },
-    
-            //Check if the given Address is valid or not
-            validateAddr: function(inpAddr) {
-                if (!inpAddr)
-                    return false;
-                try {
-                    var addr = new Bitcoin.Address(inpAddr);
+                if (isfloID && pubKey_floID == key.getBitcoinAddress())
                     return true;
-                } catch {
-                    return false;
-                }
-            },
-    
-            //Split the str using shamir's Secret and Returns the shares 
-            createShamirsSecretShares: function(str, total_shares, threshold_limit) {
-                try {
-                    if (str.length > 0) {
-                        var strHex = shamirSecretShare.str2hex(str);
-                        var shares = shamirSecretShare.share(strHex, total_shares, threshold_limit);
-                        return shares;
-                    }
-                    return false;
-                } catch {
-                    return false
-                }
-            },
-    
-            //Verifies the shares and str
-            verifyShamirsSecret: function(sharesArray, str) {
-                return (str && this.retrieveShamirSecret(sharesArray) === str)
-            },
-    
-            //Returns the retrived secret by combining the shamirs shares
-            retrieveShamirSecret: function(sharesArray) {
-                try {
-                    if (sharesArray.length > 0) {
-                        var comb = shamirSecretShare.combine(sharesArray.slice(0, sharesArray.length));
-                        comb = shamirSecretShare.hex2str(comb);
-                        return comb;
-                    }
-                    return false;
-                } 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;
-                    }
+                else if (!isfloID && pubKey_floID == key.getPubKeyHex())
                     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)));
+                    return false;
+            } catch (e) {
+                console.error(e);
             }
-        }
-    </script>
-    <script id="floBlockchainAPI" version="2.0.1c">
-        /* 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) {
-                    return new Promise((resolve, reject) => {
-                        this.serverList.splice(this.curPos, 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) {
-                    return new Promise((resolve, reject) => {
-                        if (this.serverList.length === 0)
-                            reject("No floSight server working")
-                        else {
-                            fetch(this.serverList[this.curPos] + apicall).then(response => {
-                                if (response.ok)
-                                    response.json().then(data => resolve(data));
-                                else {
-                                    this.fetch_retry(apicall)
-                                        .then(result => resolve(result))
-                                        .catch(error => reject(error));
-                                }
-                            }).catch(error => {
-                                this.fetch_retry(apicall)
-                                    .then(result => resolve(result))
-                                    .catch(error => reject(error));
-                            })
-                        }
-                    })
+        },
+
+        //Check if the given Address is valid or not
+        validateAddr: function(inpAddr) {
+            if (!inpAddr)
+                return false;
+            try {
+                var addr = new Bitcoin.Address(inpAddr);
+                return true;
+            } catch {
+                return false;
+            }
+        },
+
+        //Split the str using shamir's Secret and Returns the shares 
+        createShamirsSecretShares: function(str, total_shares, threshold_limit) {
+            try {
+                if (str.length > 0) {
+                    var strHex = shamirSecretShare.str2hex(str);
+                    var shares = shamirSecretShare.share(strHex, total_shares, threshold_limit);
+                    return shares;
                 }
-            },
-    
-            //Promised function to get data from API
-            promisedAPI: function(apicall) {
+                return false;
+            } catch {
+                return false
+            }
+        },
+
+        //Verifies the shares and str
+        verifyShamirsSecret: function(sharesArray, str) {
+            return (str && this.retrieveShamirSecret(sharesArray) === str)
+        },
+
+        //Returns the retrived secret by combining the shamirs shares
+        retrieveShamirSecret: function(sharesArray) {
+            try {
+                if (sharesArray.length > 0) {
+                    var comb = shamirSecretShare.combine(sharesArray.slice(0, sharesArray.length));
+                    comb = shamirSecretShare.hex2str(comb);
+                    return comb;
+                }
+                return false;
+            } 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" version="2.1.1a">
+    /* 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 - 1),
+            fetch_retry: function(apicall, rm_flosight) {
                 return new Promise((resolve, reject) => {
-                    console.log(apicall)
-                    this.util.fetch_api(apicall)
+                    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));
-                });
+                })
             },
-    
-            //Get balance for the given Address
-            getBalance: function(addr) {
+            fetch_api: function(apicall) {
                 return new Promise((resolve, reject) => {
-                    this.promisedAPI(`api/addr/${addr}/balance`)
-                        .then(balance => resolve(parseFloat(balance)))
-                        .catch(error => reject(error));
-                });
-            },
-    
-            //Write Data into blockchain
-            writeData: function(senderAddr, data, privKey, receiverAddr = floGlobals.adminID) {
-                return new Promise((resolve, reject) => {
-                    if (typeof data != "string")
-                        data = JSON.stringify(data);
-                    this.sendTx(senderAddr, receiverAddr, floGlobals.sendAmt, privKey, data)
-                        .then(txid => resolve(txid))
-                        .catch(error => reject(error))
-                });
-            },
-    
-            //Send Tx to blockchain 
-            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))
-                        reject(`Invalid address : ${receiverAddr}`);
-                    if (privKey.length < 1 || !floCrypto.verifyPrivKey(privKey, senderAddr))
-                        reject("Invalid Private key!");
-                    else if (typeof sendAmt !== 'number' || sendAmt <= 0)
-                        reject(`Invalid sendAmt : ${sendAmt}`);
+                    if (this.serverList.length === 0)
+                        reject("No floSight server working");
                     else {
-                        var trx = bitjs.transaction();
-                        var utxoAmt = 0.0;
-                        var fee = floGlobals.fee;
+                        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, flosight)
+                                    .then(result => resolve(result))
+                                    .catch(error => reject(error));
+                            }
+                        }).catch(error => {
+                            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) {
+            return new Promise((resolve, reject) => {
+                //console.log(apicall);
+                this.util.fetch_api(apicall)
+                    .then(result => resolve(result))
+                    .catch(error => reject(error));
+            });
+        },
+
+        //Get balance for the given Address
+        getBalance: function(addr) {
+            return new Promise((resolve, reject) => {
+                this.promisedAPI(`api/addr/${addr}/balance`)
+                    .then(balance => resolve(parseFloat(balance)))
+                    .catch(error => reject(error));
+            });
+        },
+
+        //Write Data into blockchain
+        writeData: function(senderAddr, data, privKey, receiverAddr = floGlobals.adminID, strict_utxo = true) {
+            return new Promise((resolve, reject) => {
+                if (typeof data != "string")
+                    data = JSON.stringify(data);
+                this.sendTx(senderAddr, receiverAddr, floGlobals.sendAmt, privKey, data, strict_utxo)
+                    .then(txid => resolve(txid))
+                    .catch(error => reject(error));
+            });
+        },
+
+        //Send Tx to blockchain 
+        sendTx: function(senderAddr, receiverAddr, sendAmt, privKey, floData = '', strict_utxo = true) {
+            return new Promise((resolve, reject) => {
+                if (!floCrypto.validateASCII(floData))
+                    return reject("Invalid FLO_Data: only printable ASCII characters are allowed");
+                else if (!floCrypto.validateAddr(senderAddr))
+                    return reject(`Invalid address : ${senderAddr}`);
+                else if (!floCrypto.validateAddr(receiverAddr))
+                    return reject(`Invalid address : ${receiverAddr}`);
+                else if (privKey.length < 1 || !floCrypto.verifyPrivKey(privKey, senderAddr))
+                    return reject("Invalid Private key!");
+                else if (typeof sendAmt !== 'number' || sendAmt <= 0)
+                    return reject(`Invalid sendAmt : ${sendAmt}`);
+
+                //get unconfirmed tx list
+                this.promisedAPI(`api/addr/${senderAddr}`).then(result => {
+                    this.readTxs(senderAddr, 0, result.unconfirmedTxApperances).then(result => {
+                        let unconfirmedSpent = {};
+                        for (let tx of result.items)
+                            if (tx.confirmations == 0)
+                                for (let vin of tx.vin)
+                                    if (vin.addr === senderAddr) {
+                                        if (Array.isArray(unconfirmedSpent[vin.txid]))
+                                            unconfirmedSpent[vin.txid].push(vin.vout);
+                                        else
+                                            unconfirmedSpent[vin.txid] = [vin.vout];
+                                    }
+                        //get utxos list
                         this.promisedAPI(`api/addr/${senderAddr}/utxo`).then(utxos => {
+                            //form/construct the transaction data
+                            var trx = bitjs.transaction();
+                            var utxoAmt = 0.0;
+                            var fee = floGlobals.fee;
                             for (var i = utxos.length - 1;
                                 (i >= 0) && (utxoAmt < sendAmt + fee); i--) {
-                                if (utxos[i].confirmations) {
-                                    trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i]
-                                        .scriptPubKey)
+                                //use only utxos with confirmations (strict_utxo mode)
+                                if (utxos[i].confirmations || !strict_utxo) {
+                                    if (utxos[i].txid in unconfirmedSpent && unconfirmedSpent[utxos[i].txid].includes(utxos[i].vout))
+                                        continue; //A transaction has already used this utxo, but is unconfirmed.
+                                    trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i].scriptPubKey);
                                     utxoAmt += utxos[i].amount;
-                                } else break;
+                                };
                             }
                             if (utxoAmt < sendAmt + fee)
-                                reject("Insufficient balance!");
+                                reject("Insufficient FLO balance!");
                             else {
                                 trx.addoutput(receiverAddr, sendAmt);
                                 var change = utxoAmt - sendAmt - fee;
@@ -7473,1932 +7496,1610 @@
                                     .catch(error => reject(error))
                             }
                         }).catch(error => reject(error))
+                    }).catch(error => reject(error))
+                }).catch(error => reject(error))
+            });
+        },
+
+        //merge all UTXOs of a given floID into a single UTXO
+        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;
+                var fee = floGlobals.fee;
+                this.promisedAPI(`api/addr/${floID}/utxo`).then(utxos => {
+                    for (var i = utxos.length - 1; i >= 0; i--)
+                        if (utxos[i].confirmations) {
+                            trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i].scriptPubKey);
+                            utxoAmt += utxos[i].amount;
+                        }
+                    trx.addoutput(floID, utxoAmt - fee);
+                    trx.addflodata(floData.replace(/\n/g, ' '));
+                    var signedTxHash = trx.sign(privKey, 1);
+                    this.broadcastTx(signedTxHash)
+                        .then(txid => resolve(txid))
+                        .catch(error => reject(error))
+                }).catch(error => reject(error))
+            })
+        },
+
+        /**Write data into blockchain from (and/or) to multiple floID
+         * @param  {Array} senderPrivKeys List of sender private-keys
+         * @param  {string} data FLO data of the txn
+         * @param  {Array} receivers List of receivers
+         * @param  {boolean} preserveRatio (optional) preserve ratio or equal contribution
+         * @return {Promise}
+         */
+        writeDataMultiple: function(senderPrivKeys, data, receivers = [floGlobals.adminID], preserveRatio = true) {
+            return new Promise((resolve, reject) => {
+                if (!Array.isArray(senderPrivKeys))
+                    return reject("Invalid senderPrivKeys: SenderPrivKeys must be Array");
+                if (!preserveRatio) {
+                    let tmp = {};
+                    let amount = (floGlobals.sendAmt * receivers.length) / senderPrivKeys.length;
+                    senderPrivKeys.forEach(key => tmp[key] = amount);
+                    senderPrivKeys = tmp;
+                }
+                if (!Array.isArray(receivers))
+                    return reject("Invalid receivers: Receivers must be Array");
+                else {
+                    let tmp = {};
+                    let amount = floGlobals.sendAmt;
+                    receivers.forEach(floID => tmp[floID] = amount);
+                    receivers = tmp
+                }
+                if (typeof data != "string")
+                    data = JSON.stringify(data);
+                this.sendTxMultiple(senderPrivKeys, receivers, data)
+                    .then(txid => resolve(txid))
+                    .catch(error => reject(error))
+            })
+        },
+
+        /**Send Tx from (and/or) to multiple floID
+         * @param  {Array or Object} senderPrivKeys List of sender private-key (optional: with coins to be sent)
+         * @param  {Object} receivers List of receivers with respective amount to be sent
+         * @param  {string} floData FLO data of the txn
+         * @return {Promise}
+         */
+        sendTxMultiple: function(senderPrivKeys, receivers, floData = '') {
+            return new Promise((resolve, reject) => {
+                if (!floCrypto.validateASCII(floData))
+                    return reject("Invalid FLO_Data: only printable ASCII characters are allowed");
+                let senders = {},
+                    preserveRatio;
+                //check for argument validations
+                try {
+                    let invalids = {
+                        InvalidSenderPrivKeys: [],
+                        InvalidSenderAmountFor: [],
+                        InvalidReceiverIDs: [],
+                        InvalidReceiveAmountFor: []
                     }
-                });
-            },
-    
-            //merge all UTXOs of a given floID into a single UTXO
-            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;
-                    var fee = floGlobals.fee;
-                    this.promisedAPI(`api/addr/${floID}/utxo`).then(utxos => {
-                        for (var i = utxos.length - 1; i >= 0; i--) {
-                            if (utxos[i].confirmations) {
-                                trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i]
-                                    .scriptPubKey)
-                                utxoAmt += utxos[i].amount;
+                    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)) {
+                        senderPrivKeys.forEach(key => {
+                            try {
+                                if (!key)
+                                    invalids.InvalidSenderPrivKeys.push(key);
+                                else {
+                                    let floID = floCrypto.getFloID(key);
+                                    senders[floID] = {
+                                        wif: key
+                                    }
+                                }
+                            } 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)
+                                    invalids.InvalidSenderPrivKeys.push(key);
+                                else {
+                                    if (typeof senderPrivKeys[key] !== 'number' || senderPrivKeys[key] <= 0)
+                                        invalids.InvalidSenderAmountFor.push(key);
+                                    else
+                                        inputVal += senderPrivKeys[key];
+                                    let floID = floCrypto.getFloID(key);
+                                    senders[floID] = {
+                                        wif: key,
+                                        coins: senderPrivKeys[key]
+                                    }
+                                }
+                            } catch (error) {
+                                invalids.InvalidSenderPrivKeys.push(key)
                             }
                         }
-                        trx.addoutput(floID, utxoAmt - fee);
+                        preserveRatio = false;
+                    }
+                    //Validate the receiver IDs and receive amount
+                    for (let floID in receivers) {
+                        if (!floCrypto.validateAddr(floID))
+                            invalids.InvalidReceiverIDs.push(floID);
+                        if (typeof receivers[floID] !== 'number' || receivers[floID] <= 0)
+                            invalids.InvalidReceiveAmountFor.push(floID);
+                        else
+                            outputVal += receivers[floID];
+                    }
+                    //Reject if any invalids are found
+                    for (let i in invalids)
+                        if (!invalids[i].length)
+                            delete invalids[i];
+                    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) {
+                    return reject(error)
+                }
+                //Get balance of senders
+                let promises = [];
+                for (let floID in senders)
+                    promises.push(this.getBalance(floID));
+                Promise.all(promises).then(results => {
+                    let totalBalance = 0,
+                        totalFee = floGlobals.fee,
+                        balance = {};
+                    //Divide fee among sender if not for 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))
+                            insufficient.push(floID);
+                        totalBalance += balance[floID];
+                    }
+                    if (insufficient.length)
+                        return reject({
+                            InsufficientBalance: insufficient
+                        })
+                    //Calculate totalSentAmount and check if totalBalance is sufficient
+                    let totalSendAmt = totalFee;
+                    for (floID in receivers)
+                        totalSendAmt += receivers[floID];
+                    if (totalBalance < totalSendAmt)
+                        return reject("Insufficient total Balance");
+                    //Get the UTXOs of the senders
+                    let promises = [];
+                    for (floID in senders)
+                        promises.push(this.promisedAPI(`api/addr/${floID}/utxo`));
+                    Promise.all(promises).then(results => {
+                        let wifSeq = [];
+                        var trx = bitjs.transaction();
+                        for (floID in senders) {
+                            let utxos = results.shift();
+                            let sendAmt;
+                            if (preserveRatio) {
+                                let ratio = (balance[floID] / totalBalance);
+                                sendAmt = totalSendAmt * ratio;
+                            } else
+                                sendAmt = senders[floID].coins + dividedFee;
+                            let wif = senders[floID].wif;
+                            let utxoAmt = 0.0;
+                            for (let i = utxos.length - 1;
+                                (i >= 0) && (utxoAmt < sendAmt); i--) {
+                                if (utxos[i].confirmations) {
+                                    trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i].scriptPubKey);
+                                    wifSeq.push(wif);
+                                    utxoAmt += utxos[i].amount;
+                                }
+                            }
+                            if (utxoAmt < sendAmt)
+                                return reject("Insufficient balance:" + floID);
+                            let change = (utxoAmt - sendAmt);
+                            if (change > 0)
+                                trx.addoutput(floID, change);
+                        }
+                        for (floID in receivers)
+                            trx.addoutput(floID, receivers[floID]);
                         trx.addflodata(floData.replace(/\n/g, ' '));
-                        var signedTxHash = trx.sign(privKey, 1);
+                        for (let i = 0; i < wifSeq.length; i++)
+                            trx.signinput(i, wifSeq[i], 1);
+                        var signedTxHash = trx.serialize();
                         this.broadcastTx(signedTxHash)
                             .then(txid => resolve(txid))
                             .catch(error => reject(error))
                     }).catch(error => reject(error))
-                })
-            },
-    
-            /**Write data into blockchain from (and/or) to multiple floID
-             * @param  {Array} senderPrivKeys List of sender private-keys
-             * @param  {string} data FLO data of the txn
-             * @param  {Array} receivers List of receivers
-             * @param  {boolean} preserveRatio (optional) preserve ratio or equal contribution
-             * @return {Promise}
-             */
-            writeDataMultiple: function(senderPrivKeys, data, receivers = [floGlobals.adminID], preserveRatio = true) {
-                return new Promise((resolve, reject) => {
-                    if (!Array.isArray(senderPrivKeys))
-                        return reject("Invalid senderPrivKeys: SenderPrivKeys must be Array")
-                    if (!preserveRatio) {
-                        let tmp = {};
-                        let amount = (floGlobals.sendAmt * receivers.length) / senderPrivKeys.length;
-                        senderPrivKeys.forEach(key => tmp[key] = amount);
-                        senderPrivKeys = tmp
+                }).catch(error => reject(error))
+            })
+        },
+
+        //Broadcast signed Tx in blockchain using API
+        broadcastTx: function(signedTxHash) {
+            return new Promise((resolve, reject) => {
+                var request = new XMLHttpRequest();
+                var url = this.util.serverList[this.util.curPos] + 'api/tx/send';
+                console.log(url);
+                if (signedTxHash.length < 1)
+                    reject("Empty Signature");
+                else {
+                    var params = `{"rawtx":"${signedTxHash}"}`;
+                    request.open('POST', url, true);
+                    //Send the proper header information along with the request
+                    request.setRequestHeader('Content-type', 'application/json');
+                    request.onload = function() {
+                        if (request.readyState == 4 && request.status == 200) {
+                            console.log(request.response);
+                            resolve(JSON.parse(request.response).txid.result);
+                        } else
+                            reject(request.responseText);
                     }
-                    if (!Array.isArray(receivers))
-                        return reject("Invalid receivers: Receivers must be Array")
-                    else {
-                        let tmp = {};
-                        let amount = floGlobals.sendAmt;
-                        receivers.forEach(floID => tmp[floID] = amount);
-                        receivers = tmp
-                    }
-                    if (typeof data != "string")
-                        data = JSON.stringify(data);
-                    this.sendTxMultiple(senderPrivKeys, receivers, data)
-                        .then(txid => resolve(txid))
-                        .catch(error => reject(error))
-                })
-            },
-    
-            /**Send Tx from (and/or) to multiple floID
-             * @param  {Array or Object} senderPrivKeys List of sender private-key (optional: with coins to be sent)
-             * @param  {Object} receivers List of receivers with respective amount to be sent
-             * @param  {string} floData FLO data of the txn
-             * @return {Promise}
-             */
-            sendTxMultiple: function(senderPrivKeys, receivers, floData = '') {
-                return new Promise((resolve, reject) => {
-                    if (!floCrypto.validateASCII(floData))
-                        return reject("Invalid FLO_Data: only printable ASCII characters are allowed");
-                    let senders = {},
-                        preserveRatio;
-                    //check for argument validations
-                    try {
-                        let invalids = {
-                            InvalidSenderPrivKeys: [],
-                            InvalidSenderAmountFor: [],
-                            InvalidReceiverIDs: [],
-                            InvalidReceiveAmountFor: []
-                        }
-                        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)) {
-                            senderPrivKeys.forEach(key => {
-                                try {
-                                    if (!key)
-                                        invalids.InvalidSenderPrivKeys.push(key);
-                                    else {
-                                        let floID = floCrypto.getFloID(key);
-                                        senders[floID] = {
-                                            wif: key
-                                        }
-                                    }
-                                } 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)
-                                        invalids.InvalidSenderPrivKeys.push(key);
-                                    else {
-                                        if (typeof senderPrivKeys[key] !== 'number' || senderPrivKeys[
-                                                key] <= 0)
-                                            invalids.InvalidSenderAmountFor.push(key)
-                                        else
-                                            inputVal += senderPrivKeys[key];
-                                        let floID = floCrypto.getFloID(key);
-                                        senders[floID] = {
-                                            wif: key,
-                                            coins: senderPrivKeys[key]
-                                        }
-                                    }
-                                } catch (error) {
-                                    invalids.InvalidSenderPrivKeys.push(key)
-                                }
-                            }
-                            preserveRatio = false;
-                        }
-                        //Validate the receiver IDs and receive amount
-                        for (let floID in receivers) {
-                            if (!floCrypto.validateAddr(floID))
-                                invalids.InvalidReceiverIDs.push(floID)
-                            if (typeof receivers[floID] !== 'number' || receivers[floID] <= 0)
-                                invalids.InvalidReceiveAmountFor.push(floID)
-                            else
-                                outputVal += receivers[floID];
-                        }
-                        //Reject if any invalids are found
-                        for (let i in invalids)
-                            if (!invalids[i].length)
-                                delete invalids[i];
-                        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) {
-                        return reject(error)
-                    }
-                    //Get balance of senders
-                    let promises = []
-                    for (let floID in senders)
-                        promises.push(this.getBalance(floID))
-                    Promise.all(promises).then(results => {
-                        let totalBalance = 0,
-                            totalFee = floGlobals.fee,
-                            balance = {};
-                        //Divide fee among sender if not for 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))
-                                insufficient.push(floID)
-                            totalBalance += balance[floID];
-                        }
-                        if (insufficient.length)
-                            return reject({
-                                InsufficientBalance: insufficient
-                            })
-                        //Calculate totalSentAmount and check if totalBalance is sufficient
-                        let totalSendAmt = totalFee;
-                        for (floID in receivers)
-                            totalSendAmt += receivers[floID];
-                        if (totalBalance < totalSendAmt)
-                            return reject("Insufficient total Balance")
-                        //Get the UTXOs of the senders
-                        let promises = []
-                        for (floID in senders)
-                            promises.push(this.promisedAPI(`api/addr/${floID}/utxo`))
-                        Promise.all(promises).then(results => {
-                            let wifSeq = [];
-                            var trx = bitjs.transaction();
-                            for (floID in senders) {
-                                let utxos = results.shift();
-                                let sendAmt;
-                                if (preserveRatio) {
-                                    let ratio = (balance[floID] / totalBalance);
-                                    sendAmt = totalSendAmt * ratio;
-                                } else
-                                    sendAmt = senders[floID].coins + dividedFee;
-                                let wif = senders[floID].wif;
-                                let utxoAmt = 0.0;
-                                for (let i = utxos.length - 1;
-                                    (i >= 0) && (utxoAmt < sendAmt); i--) {
-                                    if (utxos[i].confirmations) {
-                                        trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i]
-                                            .scriptPubKey)
-                                        wifSeq.push(wif);
-                                        utxoAmt += utxos[i].amount;
-                                    }
-                                }
-                                if (utxoAmt < sendAmt)
-                                    return reject("Insufficient balance:" + floID);
-                                let change = (utxoAmt - sendAmt);
-                                if (change > 0)
-                                    trx.addoutput(floID, change);
-                            }
-                            for (floID in receivers)
-                                trx.addoutput(floID, receivers[floID]);
-                            trx.addflodata(floData.replace(/\n/g, ' '));
-                            for (let i = 0; i < wifSeq.length; i++)
-                                trx.signinput(i, wifSeq[i], 1);
-                            var signedTxHash = trx.serialize();
-                            this.broadcastTx(signedTxHash)
-                                .then(txid => resolve(txid))
-                                .catch(error => reject(error))
-                        }).catch(error => reject(error))
-                    }).catch(error => reject(error))
-                })
-            },
-    
-            //Broadcast signed Tx in blockchain using API
-            broadcastTx: function(signedTxHash) {
-                return new Promise((resolve, reject) => {
-                    var request = new XMLHttpRequest();
-                    var url = this.util.serverList[this.util.curPos] + 'api/tx/send';
-                    console.log(url)
-                    if (signedTxHash.length < 1)
-                        reject("Empty Signature");
-                    else {
-                        var params = `{"rawtx":"${signedTxHash}"}`;
-                        request.open('POST', url, true);
-                        //Send the proper header information along with the request
-                        request.setRequestHeader('Content-type', 'application/json');
-                        request.onload = function() {
-                            if (request.readyState == 4 && request.status == 200) {
-                                console.log(request.response);
-                                resolve(JSON.parse(request.response).txid.result);
-                            } else
-                                reject(request.responseText);
-                        }
-                        request.send(params);
-                    }
-                })
-            },
-    
-            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) {
-                return new Promise((resolve, reject) => {
-                    this.promisedAPI(`api/addrs/${addr}/txs?from=${from}&to=${to}`)
-                        .then(response => resolve(response))
-                        .catch(error => reject(error))
-                });
-            },
-    
-            //Read All Txs of Address (newest first)
-            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`)
-                            .then(response => resolve(response.items))
-                            .catch(error => reject(error));
-                    }).catch(error => reject(error))
-                });
-            },
-    
-            /*Read flo Data from txs of given Address
-            options can be used to filter data
-            limit       : maximum number of filtered data (default = 1000, negative  = no limit)
-            ignoreOld   : ignore old txs (default = 0)
-            sentOnly    : filters only sent data
-            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 || 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;
-                        this.promisedAPI(`api/addrs/${addr}/txs?from=0&to=${newItems*2}`).then(
-                            response => {
-                                if (options.limit <= 0)
-                                    options.limit = response.items.length;
-                                var filteredData = [];
-                                for (i = 0; i < (response.totalItems - options.ignoreOld) &&
-                                    filteredData.length < options.limit; i++) {
-                                    if (options.pattern) {
-                                        try {
-                                            let jsonContent = JSON.parse(response.items[i].floData)
-                                            if (!Object.keys(jsonContent).includes(options.pattern))
-                                                continue;
-                                        } catch (error) {
+                    request.send(params);
+                }
+            })
+        },
+
+        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) {
+            return new Promise((resolve, reject) => {
+                this.promisedAPI(`api/addrs/${addr}/txs?from=${from}&to=${to}`)
+                    .then(response => resolve(response))
+                    .catch(error => reject(error))
+            });
+        },
+
+        //Read All Txs of Address (newest first)
+        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`)
+                        .then(response => resolve(response.items))
+                        .catch(error => reject(error));
+                }).catch(error => reject(error))
+            });
+        },
+
+        /*Read flo Data from txs of given Address
+        options can be used to filter data
+        limit       : maximum number of filtered data (default = 1000, negative  = no limit)
+        ignoreOld   : ignore old txs (default = 0)
+        sentOnly    : filters only sent data
+        receivedOnly: filters only received data
+        pattern     : filters data that with JSON pattern
+        filter      : custom filter funtion for floData (eg . filter: d => {return d[0] == '$'})
+        tx          : (boolean) resolve tx data or not (resolves an Array of Object with tx details)
+        sender      : flo-id(s) of sender
+        receiver    : flo-id(s) of receiver
+        */
+        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;
+                    this.promisedAPI(`api/addrs/${addr}/txs?from=0&to=${newItems*2}`).then(response => {
+                            if (options.limit <= 0)
+                                options.limit = response.items.length;
+                            var filteredData = [];
+                            for (let i = 0; i < (response.totalItems - options.ignoreOld) && filteredData.length < options.limit; i++) {
+                                if (options.pattern) {
+                                    try {
+                                        let jsonContent = JSON.parse(response.items[i].floData);
+                                        if (!Object.keys(jsonContent).includes(options.pattern))
                                             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))
+                                    } catch (error) {
                                         continue;
-                                    filteredData.push(options.txid ? [response.items[i].txid, response.items[i].floData] : response.items[i].floData);
+                                    }
                                 }
-                                resolve({
-                                    totalTxs: response.totalItems,
-                                    data: filteredData
-                                });
-                            }).catch(error => {
-                            reject(error);
-                        });
-                    }).catch(error => {
+                                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.tx) {
+                                    let d = {}
+                                    d.txid = response.items[i].txid;
+                                    d.time = response.items[i].time;
+                                    d.blockheight = response.items[i].blockheight;
+                                    d.data = response.items[i].floData;
+                                    filteredData.push(d);
+                                } else
+                                    filteredData.push(response.items[i].floData);
+                            }
+                            resolve({
+                                totalTxs: response.totalItems,
+                                data: filteredData
+                            });
+                        }).catch(error => {
                         reject(error);
                     });
+                }).catch(error => {
+                    reject(error);
                 });
-            }
+            });
         }
-    </script>
-    <script id="compactIDB" version="2.0.1">
-        /* Compact IndexedDB operations */
-    
-        window.indexedDB = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
-        window.IDBTransaction = window.IDBTransaction || window.webkitIDBTransaction || window.msIDBTransaction;
-        window.IDBKeyRange = window.IDBKeyRange || window.webkitIDBKeyRange || window.msIDBKeyRange;
-    
-        if (!window.indexedDB)
-            window.alert("Your browser doesn't support a stable version of IndexedDB.")
-    
-        const compactIDB = {
-    
-            setDefaultDB: function (dbName) {
-                this.defaultDB = dbName;
-            },
-    
-            upgradeDB: function (dbName, createList = null, deleteList = null) {
-                return new Promise((resolve, reject) => {
-                    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')
-                        }
-                        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;
-                        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
-                            this.upgradeDB(dbName, a_obs, d_obs)
-                            .then(result => resolve(result))
-                            .catch(error => reject(error))
-                        db.close();
-                    }
-                });
-            },
-    
-            openDB: function (dbName = this.defaultDB) {
-                return new Promise((resolve, reject) => {
-                    var idb = indexedDB.open(dbName);
+    }
+</script>
+<script id="compactIDB" version="2.0.1">
+    /* Compact IndexedDB operations */
+
+    window.indexedDB = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
+    window.IDBTransaction = window.IDBTransaction || window.webkitIDBTransaction || window.msIDBTransaction;
+    window.IDBKeyRange = window.IDBKeyRange || window.webkitIDBKeyRange || window.msIDBKeyRange;
+
+    if (!window.indexedDB)
+        window.alert("Your browser doesn't support a stable version of IndexedDB.")
+
+    const compactIDB = {
+
+        setDefaultDB: function (dbName) {
+            this.defaultDB = dbName;
+        },
+
+        upgradeDB: function (dbName, createList = null, deleteList = null) {
+            return new Promise((resolve, reject) => {
+                this.getDBversion(dbName).then(version => {
+                    var idb = indexedDB.open(dbName, version + 1);
                     idb.onerror = (event) => reject("Error in opening IndexedDB");
                     idb.onupgradeneeded = (event) => {
-                        event.target.result.close();
-                        this.deleteDB(dbName)
-                        reject("Datebase not found")
+                        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')
                     }
-                    idb.onsuccess = (event) => resolve(event.target.result);
-                });
-            },
-    
-            deleteDB: function (dbName = this.defaultDB) {
-                return new Promise((resolve, reject) => {
-                    var deleteReq = indexedDB.deleteDatabase(dbName);;
-                    deleteReq.onerror = (event) => reject("Error deleting database!");
-                    deleteReq.onsuccess = (event) => resolve("Database deleted successfully");
-                });
-            },
-    
-            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);
-                        let writeReq = (key ? obs.put(data, key) : obs.put(data));
-                        writeReq.onsuccess = (evt) => resolve(`Write data Successful`);
-                        writeReq.onerror = (evt) => reject(
-                            `Write data unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`
-                        );
-                        db.close();
-                    }).catch(error => reject(error));
-                });
-            },
-    
-            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);
-                        let addReq = (key ? obs.add(data, key) : obs.add(data));
-                        addReq.onsuccess = (evt) => resolve(`Add data successful`);
-                        addReq.onerror = (evt) => reject(
-                            `Add data unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`
-                        );
-                        db.close();
-                    }).catch(error => reject(error));
-                });
-            },
-    
-            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);
-                        let delReq = obs.delete(key);
-                        delReq.onsuccess = (evt) => resolve(`Removed Data ${key}`);
-                        delReq.onerror = (evt) => reject(
-                            `Remove data unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`
-                        );
-                        db.close();
-                    }).catch(error => reject(error));
-                });
-            },
-    
-            clearData: function (obsName, dbName = this.defaultDB) {
-                return new Promise((resolve, reject) => {
-                    this.openDB(dbName).then(db => {
-                        var obs = db.transaction(obsName, "readwrite").objectStore(obsName);
-                        let clearReq = obs.clear();
-                        clearReq.onsuccess = (evt) => resolve(`Clear data Successful`);
-                        clearReq.onerror = (evt) => reject(`Clear data Unsuccessful`);
-                        db.close();
-                    }).catch(error => reject(error));
-                });
-            },
-    
-            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);
-                        let getReq = obs.get(key);
-                        getReq.onsuccess = (evt) => resolve(evt.target.result);
-                        getReq.onerror = (evt) => reject(
-                            `Read data unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`
-                        );
-                        db.close();
-                    }).catch(error => reject(error));
-                });
-            },
-    
-            readAllData: function (obsName, dbName = this.defaultDB) {
-                return new Promise((resolve, reject) => {
-                    this.openDB(dbName).then(db => {
-                        var obs = db.transaction(obsName, "readonly").objectStore(obsName);
-                        var tmpResult = {}
-                        let curReq = obs.openCursor();
-                        curReq.onsuccess = (evt) => {
-                            var cursor = evt.target.result;
-                            if (cursor) {
-                                tmpResult[cursor.primaryKey] = cursor.value;
+                    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;
+                    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
+                        this.upgradeDB(dbName, a_obs, d_obs)
+                        .then(result => resolve(result))
+                        .catch(error => reject(error))
+                    db.close();
+                }
+            });
+        },
+
+        openDB: function (dbName = this.defaultDB) {
+            return new Promise((resolve, reject) => {
+                var idb = indexedDB.open(dbName);
+                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) {
+            return new Promise((resolve, reject) => {
+                var deleteReq = indexedDB.deleteDatabase(dbName);;
+                deleteReq.onerror = (event) => reject("Error deleting database!");
+                deleteReq.onsuccess = (event) => resolve("Database deleted successfully");
+            });
+        },
+
+        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);
+                    let writeReq = (key ? obs.put(data, key) : obs.put(data));
+                    writeReq.onsuccess = (evt) => resolve(`Write data Successful`);
+                    writeReq.onerror = (evt) => reject(
+                        `Write data unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`
+                    );
+                    db.close();
+                }).catch(error => reject(error));
+            });
+        },
+
+        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);
+                    let addReq = (key ? obs.add(data, key) : obs.add(data));
+                    addReq.onsuccess = (evt) => resolve(`Add data successful`);
+                    addReq.onerror = (evt) => reject(
+                        `Add data unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`
+                    );
+                    db.close();
+                }).catch(error => reject(error));
+            });
+        },
+
+        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);
+                    let delReq = obs.delete(key);
+                    delReq.onsuccess = (evt) => resolve(`Removed Data ${key}`);
+                    delReq.onerror = (evt) => reject(
+                        `Remove data unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`
+                    );
+                    db.close();
+                }).catch(error => reject(error));
+            });
+        },
+
+        clearData: function (obsName, dbName = this.defaultDB) {
+            return new Promise((resolve, reject) => {
+                this.openDB(dbName).then(db => {
+                    var obs = db.transaction(obsName, "readwrite").objectStore(obsName);
+                    let clearReq = obs.clear();
+                    clearReq.onsuccess = (evt) => resolve(`Clear data Successful`);
+                    clearReq.onerror = (evt) => reject(`Clear data Unsuccessful`);
+                    db.close();
+                }).catch(error => reject(error));
+            });
+        },
+
+        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);
+                    let getReq = obs.get(key);
+                    getReq.onsuccess = (evt) => resolve(evt.target.result);
+                    getReq.onerror = (evt) => reject(
+                        `Read data unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`
+                    );
+                    db.close();
+                }).catch(error => reject(error));
+            });
+        },
+
+        readAllData: function (obsName, dbName = this.defaultDB) {
+            return new Promise((resolve, reject) => {
+                this.openDB(dbName).then(db => {
+                    var obs = db.transaction(obsName, "readonly").objectStore(obsName);
+                    var tmpResult = {}
+                    let curReq = obs.openCursor();
+                    curReq.onsuccess = (evt) => {
+                        var cursor = evt.target.result;
+                        if (cursor) {
+                            tmpResult[cursor.primaryKey] = cursor.value;
+                            cursor.continue();
+                        } else
+                            resolve(tmpResult);
+                    }
+                    curReq.onerror = (evt) => reject(
+                        `Read-All data unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`
+                    );
+                    db.close();
+                }).catch(error => reject(error));
+            });
+        },
+
+        /*searchData: function (obsName, options = {}, dbName = this.defaultDB) {
+            
+            return new Promise((resolve, reject) => {
+                this.openDB(dbName).then(db => {
+                    var obs = db.transaction(obsName, "readonly").objectStore(obsName);
+                    var filteredResult = {}
+                    let keyRange;
+                    if(options.lowerKey!==null && options.upperKey!==null)
+                        keyRange = IDBKeyRange.bound(options.lowerKey, options.upperKey);
+                    else if(options.lowerKey!==null)
+                        keyRange = IDBKeyRange.lowerBound(options.lowerKey);
+                    else if (options.upperKey!==null)
+                        keyRange = IDBKeyRange.upperBound(options.upperBound);
+                    else if (options.atKey)
+                    let curReq = obs.openCursor(keyRange, )
+                }).catch(error => reject(error))
+            })
+        },*/
+
+        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.limit = options.limit || false;
+            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(
+                        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 (options.patternEval(cursor.primaryKey, cursor.value)) {
+                                filteredResult[cursor.primaryKey] = cursor.value;
+                                options.lastOnly ? resolve(filteredResult) : cursor.continue();
+                            } else
                                 cursor.continue();
-                            } else
-                                resolve(tmpResult);
-                        }
-                        curReq.onerror = (evt) => reject(
-                            `Read-All data unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`
-                        );
-                        db.close();
-                    }).catch(error => reject(error));
-                });
-            },
-    
-            /*searchData: function (obsName, options = {}, dbName = this.defaultDB) {
-                
-                return new Promise((resolve, reject) => {
-                    this.openDB(dbName).then(db => {
-                        var obs = db.transaction(obsName, "readonly").objectStore(obsName);
-                        var filteredResult = {}
-                        let keyRange;
-                        if(options.lowerKey!==null && options.upperKey!==null)
-                            keyRange = IDBKeyRange.bound(options.lowerKey, options.upperKey);
-                        else if(options.lowerKey!==null)
-                            keyRange = IDBKeyRange.lowerBound(options.lowerKey);
-                        else if (options.upperKey!==null)
-                            keyRange = IDBKeyRange.upperBound(options.upperBound);
-                        else if (options.atKey)
-                        let curReq = obs.openCursor(keyRange, )
-                    }).catch(error => reject(error))
-                })
-            },*/
-    
-            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.limit = options.limit || false;
-                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(
-                            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 (options.patternEval(cursor.primaryKey, cursor.value)) {
-                                    filteredResult[cursor.primaryKey] = cursor.value;
-                                    options.lastOnly ? resolve(filteredResult) : cursor.continue();
-                                } else
-                                    cursor.continue();
-                            } else
-                                resolve(filteredResult);
-                        }
-                        curReq.onerror = (evt) => reject(`Search unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`);
-                        db.close();
-                    }).catch(error => reject(error));
-                });
-            }
+                        } else
+                            resolve(filteredResult);
+                    }
+                    curReq.onerror = (evt) => reject(`Search unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`);
+                    db.close();
+                }).catch(error => reject(error));
+            });
         }
-    </script>
-    <script id="floCloudAPI" version="2.0.2e">
-        /* FLO Cloud operations to send/request application data*/
-        const floCloudAPI = {
-    
-            util: {
-    
-                kBucket: {
-                    SNKB: null,
-                    SNCO: null,
-    
-                    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;
-                        }
+    }
+</script>
+<script id="floCloudAPI" version="2.1.0a">
+    /* FLO Cloud operations to send/request application data*/
+    const floCloudAPI = {
+
+        util: {
+
+            kBucket: {
+                SNKB: null,
+                SNCO: null,
+
+                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;
                     },
-    
-                    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);
-                            }
-                        });
+
+                    addNode: function(floID, KB) {
+                        let decodedId = this.decodeID(floID);
+                        const contact = {
+                            id: decodedId,
+                            floID: floID
+                        };
+                        KB.add(contact)
                     },
-    
-                    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
+
+                    removeNode: function(floID, KB) {
+                        let decodedId = this.decodeID(floID);
+                        KB.remove(decodedId)
                     },
-    
-                    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
+
+                    isPresent: function(floID, KB) {
+                        let kArray = KB.toArray().map(k => k.floID);
+                        return kArray.includes(floID)
                     },
-    
-                    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)
+
+                    distanceOf: function(floID, KB) {
+                        let decodedId = this.decodeID(floID);
+                        return KB.distance(KB.localNodeId, decodedId);
                     },
-    
-                    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)
+
+                    closestOf: function(floID, n, KB) {
+                        let decodedId = this.decodeID(floID);
+                        return KB.closest(decodedId, n)
                     },
-    
-                    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)
+
+                    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;
                     }
                 },
-    
-                inactive: new Set(),
-                connect(snID) {
+
+                launch: function() {
                     return new Promise((resolve, reject) => {
-                        if (!(snID in floGlobals.supernodes))
-                            return reject(`${snID} is not a supernode`)
-                        let inactive = this.inactive
-                        if (inactive.has(snID))
-                            return reject(`${snID} is not active`)
-                        var wsConn = new WebSocket("wss://" + floGlobals.supernodes[snID].uri + "/ws");
-                        wsConn.onmessage = (evt) => {
-                            if (evt.data == '$+')
-                                resolve(wsConn)
-                            else if (evt.data == '$-') {
-                                wsConn.close();
-                                inactive.add(snID)
-                                reject(`${snID} is not active`)
-                            }
+                        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);
                         }
-                        wsConn.onerror = evt => {
-                            inactive.add(snID)
-                            reject(`${snID} is unavailable`)
-                        }
-                    })
+                    });
                 },
-    
-                connectActive(snID, reverse = false) {
-                    return new Promise((resolve, reject) => {
-                        if (this.inactive.size === this.kBucket.SNCO.length)
-                            return reject('Cloud offline')
-                        if (!(snID in floGlobals.supernodes))
-                            snID = this.kBucket.closestNode(snID);
-                        this.connect(snID)
-                            .then(node => resolve(node))
+
+                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)
+                }
+            },
+
+            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`)
+                    }
+                })
+            },
+
+            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))
+                        })
+                })
+            },
+
+            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 => {
-                                if (reverse)
-                                    var nxtNode = this.kBucket.prevNode(snID);
-                                else
-                                    var nxtNode = this.kBucket.nextNode(snID);
-                                this.connectActive(nxtNode, reverse)
-                                    .then(node => resolve(node))
+                                response.text()
+                                    .then(result => reject(result)) //Error Message from Node
                                     .catch(error => reject(error))
                             })
-                    })
-                },
-    
-                singleRequest: function(floID, data) {
-                    return new Promise((resolve, reject) => {
-                        this.connectActive(floID).then(node => {
-                            let randID = floCrypto.randString(5);
-                            node.send(`${floID}|${randID}:${JSON.stringify(data)}`);
-                            node.onmessage = (evt) => {
-                                if (evt.data.startsWith(randID, 1)) {
-                                    try {
-                                        let data = JSON.parse(evt.data.substring(42))
-                                        resolve(data)
-                                    } catch (error) {
-                                        reject(evt.data.substring(42))
-                                    } finally {
-                                        node.close()
-                                    }
-                                }
+                    }).catch(error => reject(error))
+                })
+            },
+
+            liveRequest: function(floID, 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)
                             }
-                        }).catch(error => reject(error));
-                    });
-                },
-    
-                liveRequest: function(floID, datareq, callback) {
-                    let request = {
-                        ...datareq.request
-                    };
-                    const checkFilter = (v, d, r) =>
-                        (!r.atVectorClock || r.atVectorClock == v) &&
-                        (r.atVectorClock || !r.lowerVectorClock || r.lowerVectorClock <= v) &&
-                        (r.atVectorClock || !r.upperVectorClock || r.upperVectorClock >= v) &&
-                        r.application == d.application &&
-                        r.receiverID == d.receiverID &&
-                        (!r.comment || r.comment == d.comment) &&
-                        (!r.type || r.type == d.type) &&
-                        (!r.senderIDs || r.senderIDs.includes(d.senderID));
-                    return new Promise((resolve, reject) => {
-                        this.connectActive(floID).then(node => {
-                            let randID = floCrypto.randString(5);
-                            node.send(`${floID}|${randID}:${JSON.stringify(datareq)}`);
-                            node.onmessage = (evt) => {
-                                if (evt.data.startsWith(randID, 1))
-                                    var i = 42
-                                else if (evt.data.startsWith(floID, 1))
-                                    var i = 36
-                                else return;
-                                let d = e = null;
-                                try {
-                                    let data = JSON.parse(evt.data.substring(i))
-                                    let filter = {}
-                                    for (let v in data)
-                                        if (checkFilter(v, data[v], request))
-                                            filter[v] = data[v]
-                                    d = filter
-                                } catch (error) {
-                                    e = evt.data.substring(i)
-                                } finally {
-                                    callback(d, e)
-                                }
-                            }
-                            this.liveRequest[randID] = node;
-                            this.liveRequest[randID].request = request;
-                            resolve(randID)
-                        }).catch(error => reject(error));
-                    });
-                },
-    
-                encodeMessage: function(message) {
-                    return btoa(unescape(encodeURIComponent(JSON.stringify(message))))
-                },
-    
-                decodeMessage: function(message) {
-                    return JSON.parse(decodeURIComponent(escape(atob(message))))
-                },
-    
-                filterKey: function(type, options) {
-                    return type + (options.comment ? ':' + options.comment : '') +
-                        '|' + (options.receiverID || floGlobals.adminID) +
-                        '|' + (options.application || floGlobals.application);
-                },
-    
-                lastCommit: function(method, objName) {
-                    switch (method) {
-                        case "GET":
-                            return JSON.parse(this.lastCommit[objName]);
-                        case "SET":
-                            this.lastCommit[objName] = JSON.stringify(floGlobals.appObjects[objName]);
-                    }
-                },
-    
-                updateObject: function(dataSet) {
-                    try {
-                        console.log(dataSet)
-                        let updatedObjects = new Set()
-                        for (vc in dataSet) {
-                            switch (dataSet[vc].comment) {
-                                case "RESET":
-                                    if (dataSet[vc].message.reset)
-                                        floGlobals.appObjects[dataSet[vc].type] = dataSet[vc].message.reset;
-                                    break;
-                                case "UPDATE":
-                                    if (dataSet[vc].message.update)
-                                        floGlobals.appObjects[dataSet[vc].type] = mergeDiff(floGlobals
-                                            .appObjects[dataSet[vc].type], message.diff)
-                            }
-                            floGlobals.lastVC[dataSet[vc].type] = vc;
-                            updatedObjects.add(dataSet[vc].type)
                         }
-                        updatedObjects.forEach(o => {
-                            compactIDB.writeData("appObjects", floGlobals.appObjects[o], o)
-                            compactIDB.writeData("lastVC", floGlobals.lastVC[o], o)
-                        });
-                    } catch (error) {
-                        console.error(error)
-                    }
-                },
-    
-                storeGeneral: function(fk, dataSet) {
-                    try {
-                        console.log(dataSet)
-                        if (typeof floGlobals.generalData[fk] !== "object")
-                            floGlobals.generalData[fk] = {}
-                        for (let vc in dataSet)
-                            floGlobals.generalData[fk][vc] = dataSet[vc];
-                        floGlobals.lastVC[fk] = Object.keys(floGlobals.generalData[fk]).sort().pop()
-                        compactIDB.writeData("lastVC", floGlobals.lastVC[fk], fk)
-                        compactIDB.writeData("generalData", floGlobals.generalData[fk], fk)
-                    } catch (error) {
-                        console.error(error)
-                    }
+                        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]);
                 }
             },
-    
-            //send Any message to supernode cloud storage
-            sendApplicationData: function(message, type, options = {}) {
-                return new Promise((resolve, reject) => {
-                    var data = {
-                        senderID: myFloID,
-                        receiverID: options.receiverID || floGlobals.adminID,
-                        pubKey: myPubKey,
-                        message: this.util.encodeMessage(message),
-                        time: Date.now(),
-                        application: options.application || floGlobals.application,
-                        type: type,
-                        comment: options.comment || ""
-                    }
-                    let hashcontent = ["receiverID", "time", "application", "type", "message", "comment"]
-                        .map(d => data[d]).join("|")
-                    data.sign = floCrypto.signData(hashcontent, myPrivKey)
-                    this.util.singleRequest(data.receiverID, data)
-                        .then(result => {
-                            data.message = message
-                            resolve({
-                                [result.vectorClock]: data
-                            })
-                        }).catch(error => reject(error))
-                })
-            },
-    
-            //request any data from supernode cloud
-            requestApplicationData: function(type, options = {}) {
-                return new Promise((resolve, reject) => {
-                    var request = {
-                        receiverID: options.receiverID || floGlobals.adminID,
-                        senderIDs: options.senderIDs || undefined,
-                        application: options.application || floGlobals.application,
-                        type: type,
-                        comment: options.comment || undefined,
-                        lowerVectorClock: options.lowerVectorClock || undefined,
-                        upperVectorClock: options.upperVectorClock || undefined,
-                        atVectorClock: options.atVectorClock || undefined,
-                        mostRecent: options.mostRecent || undefined,
-                    }
-                    var datareq = {
-                        time: Date.now(),
-                        request
-                    }
-                    if (options.callback instanceof Function) {
-                        let callback = (d, e) => {
-                            for (let v in d)
-                                d[v].message = this.util.decodeMessage(d[v].message)
-                            options.callback(d, e)
+
+            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.diff)
+                                    floGlobals.appObjects[dataSet[vc].type] = mergeDiff(floGlobals.appObjects[dataSet[vc].type], dataSet[vc].message.diff)
                         }
-                        this.util.liveRequest(request.receiverID, datareq, callback)
-                            .then(result => resolve(result))
-                            .catch(error => reject(error))
-                    } else {
-                        this.util.singleRequest(request.receiverID, datareq).then(data => {
-                            for (let v in data)
-                                data[v].message = this.util.decodeMessage(data[v].message)
-                            resolve(data)
-                        }).catch(error => reject(error))
+                        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)
+                }
             },
-    
-            //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))
-                })
+
+            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)
+                }
             },
-    
-            //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,
+
+            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 = {}) {
+            return new Promise((resolve, reject) => {
+                var data = {
+                    senderID: myFloID,
+                    receiverID: options.receiverID || floGlobals.adminID,
+                    pubKey: myPubKey,
+                    message: this.util.encodeMessage(message),
+                    time: Date.now(),
+                    application: options.application || floGlobals.application,
+                    type: type,
+                    comment: options.comment || ""
+                }
+                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(type, options = {}) {
+            return new Promise((resolve, reject) => {
+                var request = {
+                    receiverID: options.receiverID || floGlobals.adminID,
+                    senderIDs: options.senderIDs || undefined,
+                    application: options.application || floGlobals.application,
+                    type: type,
+                    comment: options.comment || undefined,
+                    lowerVectorClock: options.lowerVectorClock || undefined,
+                    upperVectorClock: options.upperVectorClock || undefined,
+                    atVectorClock: options.atVectorClock || undefined,
+                    mostRecent: options.mostRecent || undefined,
+                }
+
+                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(),
-                            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))
+                            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
                     })
-                })
-            },
-    
-            //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 = {}) {
-                return new Promise((resolve, reject) => {
-                    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 => {
-                        //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 = {}) {
-                return new Promise((resolve, reject) => {
-                    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)
+                }).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
                         }
-                        this.requestApplicationData(type, new_options)
+                    })
+                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 = {}) {
+            return new Promise((resolve, reject) => {
+                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 => {
+                    //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 = {}) {
+            return new Promise((resolve, reject) => {
+                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 = {}) {
+            return new Promise((resolve, reject) => {
+                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;
+                }
+                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(type, options).then(dataSet => {
-                            this.util.storeGeneral(fk, dataSet)
-                            resolve(dataSet)
+                        this.requestApplicationData(objectName, options).then(dataSet => {
+                            this.util.updateObject(dataSet)
+                            this.util.lastCommit("SET", objectName)
+                            resolve(floGlobals.appObjects[objectName])
                         }).catch(error => reject(error))
                     }
-                })
-            },
-    
-            //request an object data from supernode cloud
-            requestObjectData: function(objectName, options = {}) {
-                return new Promise((resolve, reject) => {
-                    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;
-                    }
-                    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))
-                })
-            },
-    
-            closeRequest: function(requestID) {
-                return new Promise((resolve, reject) => {
-                    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]
-                    }
-                    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 = {}) {
-                return new Promise((resolve, reject) => {
-                    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))
-                })
+                }).catch(error => reject(error))
+            })
+        },
+
+        closeRequest: function(requestID) {
+            return new Promise((resolve, reject) => {
+                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]
+                }
+                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 = {}) {
+            return new Promise((resolve, reject) => {
+                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))
+            })
+        }
+    }
+
+    /*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
             }
         }
-    
-        /*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
+
+        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
-            }
-    
-            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]
+            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
             }
-    
-            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)
+            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)
         }
-    </script>
-    <script id="floDapps" version="2.0.1c">
-        /* General functions for FLO Dapps*/
-        const floDapps = {
-    
-            util: {
-    
-                initIndexedDB: function() {
-                    return new Promise((resolve, reject) => {
-                        var obs_g = {
-                            //general
-                            lastTx: {},
-                            //supernode (cloud list)
-                            supernodes: {
-                                indexes: {
-                                    uri: null,
-                                    pubKey: null
-                                }
+
+        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.1c">
+    /* General functions for FLO Dapps*/
+    const floDapps = {
+
+        util: {
+
+            initIndexedDB: function() {
+                return new Promise((resolve, reject) => {
+                    var obs_g = {
+                        //general
+                        lastTx: {},
+                        //supernode (cloud list)
+                        supernodes: {
+                            indexes: {
+                                uri: null,
+                                pubKey: null
                             }
                         }
-                        var obs_a = {
-                            //login credentials
-                            credentials: {},
-                            //for Dapps
-                            subAdmins: {},
-                            settings: {},
-                            appObjects: {},
-                            generalData: {},
-                            lastVC: {}
-                        }
-                        //add other given objectStores
-                        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));
+                    }
+                    var obs_a = {
+                        //login credentials
+                        credentials: {},
+                        //for Dapps
+                        subAdmins: {},
+                        settings: {},
+                        appObjects: {},
+                        generalData: {},
+                        lastVC: {}
+                    }
+                    //add other given objectStores
+                    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() {
+                    return new Promise((resolve, reject) => {
+                        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;
+                                    for (sn in content.removeNodes)
+                                        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, "floDapps");
+                                compactIDB.readAllData("supernodes", "floDapps").then(result => {
+                                    floGlobals.supernodes = result;
+                                    floCloudAPI.util.kBucket.launch()
+                                        .then(result => resolve("Loaded Supernode list\n" + result))
+                                        .catch(error => reject(error))
+                                })
+                            })
+                        }).catch(error => reject(error))
                     })
                 },
-    
-                initUserDB: function(floID) {
+
+                readAppConfigFromAPI: function() {
                     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'));
+                        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];
+                                    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]);
+                                    if (Array.isArray(content.addSubAdmin))
+                                        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)
+                                }
+                                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;
+                                        resolve("Read app configuration from blockchain");
+                                    })
+                                })
+                            })
+                        }).catch(error => reject(error))
                     })
                 },
-    
-                loadUserDB: function(floID) {
+
+                loadDataFromAppIDB: function() {
                     return new Promise((resolve, reject) => {
-                        var loadData = ["contacts", "pubKeys", "messages"]
+                        var loadData = ["appObjects", "generalData", "lastVC"]
                         var promises = []
                         for (var i = 0; i < loadData.length; i++)
-                            promises[i] = compactIDB.readAllData(loadData[i], `floDapps#${floID}`)
+                            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 userDB")
-                        }).catch(error => reject('Load userDB failed'))
-                    })
-                },
-    
-                startUpFunctions: {
-    
-                    readSupernodeListFromAPI: function() {
-                        return new Promise((resolve, reject) => {
-                            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;
-                                        for (sn in content.removeNodes)
-                                            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, "floDapps");
-                                    compactIDB.readAllData("supernodes", "floDapps").then(result => {
-                                        floGlobals.supernodes = result;
-                                        floCloudAPI.util.kBucket.launch()
-                                            .then(result => resolve("Loaded Supernode list\n" + result))
-                                            .catch(error => reject(error))
-                                    })
-                                })
-                            }).catch(error => reject(error))
-                        })
-                    },
-    
-                    readAppConfigFromAPI: function() {
-                        return new Promise((resolve, reject) => {
-                            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];
-                                        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]);
-                                        if (Array.isArray(content.addSubAdmin))
-                                            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)
-                                    }
-                                    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;
-                                            resolve("Read app configuration from blockchain");
-                                        })
-                                    })
-                                })
-                            }).catch(error => reject(error))
-                        })
-                    },
-    
-                    loadDataFromAppIDB: function() {
-                        return new Promise((resolve, reject) => {
-                            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 app 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 => {
-                            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))
+                            resolve("Loaded Data from app IDB")
                         }).catch(error => reject(error))
                     })
-                },
-    
-                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)
-                        })
-                    })
                 }
             },
-    
-            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.completed = 0
-                        this.util.callStartUpFunction.failed = 0
-                        var p0 = []
-                        for (fn in this.util.startUpFunctions)
-                            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) {
-                if (fname in this.util.startUpFunctions)
-                    throw (`Function ${fname} already defined`)
-                this.util.startUpFunctions[fname] = fn;
-            },
-    
-            setMidStartup: function(fn) {
-                if (fn instanceof Function)
-                    this.launchStartUp.midFunction = fn;
-            },
-    
-            setCustomStartupLogger: function(logger) {
-                this.util.startUpLog = logger;
-            },
-    
-            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 (!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,
-                            settings: settings
-                        }
-                    }
-                    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 Configuration', result]))
-                        .catch(error => reject(error))
-                })
-            },
-    
-            clearCredentials: function() {
-                return new Promise((resolve, reject) => {
-                    compactIDB.clearData('credentials', floGlobals.application).then(result => {
-                        localStorage.removeItem(`${floGlobals.application}#privKey`)
-                        myPrivKey = myPubKey = myFloID = undefined;
-                        resolve("privKey credentials deleted!")
-                    }).catch(error => reject(error))
-                })
-            },
-    
-            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)
-                        return reject("PrivKey not found");
-                    indexArr = JSON.parse(indexArr)
-                    let encryptedKey = Crypto.AES.encrypt(myPrivKey, pwd);
-                    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(overwriteFn(shares[i], indexArr[i]));
-                    Promise.all(promises)
-                        .then(results => resolve("Private Key Secured"))
-                        .catch(error => reject(error))
-                })
-            },
-    
-            verifyPin: function(pin = null) {
+
+            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 = []
@@ -9406,7 +9107,6 @@
                             promises.push(compactIDB.readData('credentials', indexArr[i]))
                         Promise.all(promises).then(shares => {
                             var secret = floCrypto.retrieveShamirSecret(shares)
-                            console.info(shares, secret)
                             if (secret)
                                 resolve(secret)
                             else
@@ -9414,119 +9114,466 @@
                         }).catch(error => reject(error))
                     })
                 }
-                return new Promise((resolve, reject) => {
-                    var indexArr = localStorage.getItem(`${floGlobals.application}#privKey`)
-                    console.info(indexArr)
-                    if (!indexArr)
-                        reject('No login credentials found')
-                    readSharesFromIDB(JSON.parse(indexArr)).then(key => {
-                        if (key.length == 52) {
-                            if (pin === null)
-                                resolve("Private key not secured")
-                            else
-                                reject("Private key not secured")
+
+                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 {
-                            if (pin === null)
-                                return reject("PIN/Password required")
-                            try {
-                                let privKey = Crypto.AES.decrypt(key, pin);
-                                resolve("PIN/Password verified")
-                            } catch (error) {
-                                reject("Incorrect PIN/Password")
-                            }
+                            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))
                 })
-    
-    
             },
-    
-            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]))
+
+            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)
+                    })
+                })
+            }
+        },
+
+        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.completed = 0
+                    this.util.callStartUpFunction.failed = 0
+                    var p0 = []
+                    for (fn in this.util.startUpFunctions)
+                        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) {
+            if (fname in this.util.startUpFunctions)
+                throw (`Function ${fname} already defined`)
+            this.util.startUpFunctions[fname] = fn;
+        },
+
+        setMidStartup: function(fn) {
+            if (fn instanceof Function)
+                this.launchStartUp.midFunction = fn;
+        },
+
+        setCustomStartupLogger: function(logger) {
+            this.util.startUpLog = logger;
+        },
+
+        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 (options.decrypt) {
-                    let decryptionKey = (options.decrypt === true) ? myPrivKey : options.decrypt;
-                    if (!Array.isArray(decryptionKey))
-                        decryptionKey = [decryptionKey];
-                    for (let f in filteredResult) {
-                        let data = filteredResult[f]
+                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 (data.message instanceof Object && "secret" in data.message) {
-                                for (let key of decryptionKey) {
-                                    try {
-                                        let tmp = floCrypto.decryptData(data.message, key)
-                                        data.message = JSON.parse(tmp)
-                                        break;
-                                    } catch (error) {}
-                                }
-                            }
+                            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 (!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,
+                        settings: settings
                     }
                 }
-                this.getNextGeneralData[fk] = Object.keys(filteredResult).sort().pop();
-                return filteredResult;
-            },
-    
-            syncData: {
-                oldDevice: function() {
-                    return new Promise((resolve, reject) => {
-                        let sync = {
-                            contacts: floGlobals.contacts,
-                            pubKeys: floGlobals.pubKeys,
-                            messages: floGlobals.messages
+                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 Configuration', result]))
+                    .catch(error => reject(error))
+            })
+        },
+
+        clearCredentials: function() {
+            return new Promise((resolve, reject) => {
+                compactIDB.clearData('credentials', floGlobals.application).then(result => {
+                    localStorage.removeItem(`${floGlobals.application}#privKey`)
+                    myPrivKey = myPubKey = myFloID = undefined;
+                    resolve("privKey credentials deleted!")
+                }).catch(error => reject(error))
+            })
+        },
+
+        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)
+                    return reject("PrivKey not found");
+                indexArr = JSON.parse(indexArr)
+                let encryptedKey = Crypto.AES.encrypt(myPrivKey, pwd);
+                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(overwriteFn(shares[i], indexArr[i]));
+                Promise.all(promises)
+                    .then(results => resolve("Private Key Secured"))
+                    .catch(error => reject(error))
+            })
+        },
+
+        verifyPin: function(pin = null) {
+            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)
+                        console.info(shares, secret)
+                        if (secret)
+                            resolve(secret)
+                        else
+                            reject("Shares are insufficient or incorrect")
+                    }).catch(error => reject(error))
+                })
+            }
+            return new Promise((resolve, reject) => {
+                var indexArr = localStorage.getItem(`${floGlobals.application}#privKey`)
+                console.info(indexArr)
+                if (!indexArr)
+                    reject('No login credentials found')
+                readSharesFromIDB(JSON.parse(indexArr)).then(key => {
+                    if (key.length == 52) {
+                        if (pin === null)
+                            resolve("Private key not secured")
+                        else
+                            reject("Private key not secured")
+                    } else {
+                        if (pin === null)
+                            return reject("PIN/Password required")
+                        try {
+                            let privKey = Crypto.AES.decrypt(key, pin);
+                            resolve("PIN/Password verified")
+                        } catch (error) {
+                            reject("Incorrect PIN/Password")
                         }
-                        let message = Crypto.AES.encrypt(JSON.stringify(sync), myPrivKey)
-                        let options = {
-                            receiverID: myFloID,
-                            application: "floDapps"
+                    }
+                }).catch(error => reject(error))
+            })
+
+
+        },
+
+        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];
+                for (let f in filteredResult) {
+                    let data = filteredResult[f]
+                    try {
+                        if (data.message instanceof Object && "secret" in data.message) {
+                            for (let key of decryptionKey) {
+                                try {
+                                    let tmp = floCrypto.decryptData(data.message, key)
+                                    data.message = JSON.parse(tmp)
+                                    break;
+                                } catch (error) {}
+                            }
                         }
-                        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))
-                    })
+                    } catch (error) {}
                 }
             }
+            this.getNextGeneralData[fk] = Object.keys(filteredResult).sort().pop();
+            return filteredResult;
+        },
+
+        syncData: {
+            oldDevice: function() {
+                return new Promise((resolve, reject) => {
+                    let sync = {
+                        contacts: floGlobals.contacts,
+                        pubKeys: floGlobals.pubKeys,
+                        messages: floGlobals.messages
+                    }
+                    let message = Crypto.AES.encrypt(JSON.stringify(sync), myPrivKey)
+                    let options = {
+                        receiverID: myFloID,
+                        application: "floDapps"
+                    }
+                    floCloudAPI.sendApplicationData(message, "syncData", options)
+                        .then(result => resolve(result))
+                        .catch(error => reject(error))
+                })
+            },
+
+            newDevice() {
+                return new Promise((resolve, reject) => {
+                    var options = {
+                        receiverID: myFloID,
+                        senderIDs: myFloID,
+                        application: "floDapps",
+                        mostRecent: true,
+                    }
+                    floCloudAPI.requestApplicationData("syncData", options).then(response => {
+                        let vc = Object.keys(response).sort().pop()
+                        let sync = JSON.parse(Crypto.AES.decrypt(response[vc].message, myPrivKey))
+                        let promises = []
+                        let store = (key, val, obs) => promises.push(compactIDB.writeData(obs, val, key, `floDapps#${floID}`));
+                        ["contacts", "pubKeys", "messages"].forEach(c => {
+                            for (let i in sync[c]) {
+                                store(i, sync[c][i], c)
+                                floGlobals[c][i] = sync[c][i]
+                            }
+                        })
+                        Promise.all(promises)
+                            .then(results => resolve("Sync data successful"))
+                            .catch(error => reject(error))
+                    }).catch(error => reject(error))
+                })
+            }
         }
-    </script>
+    }
+</script>
 </body>
 
-</html>
\ No newline at end of file
+</html>