diff --git a/standard_Operations.html b/standard_Operations.html
index 9dcf338..7917ae2 100644
--- a/standard_Operations.html
+++ b/standard_Operations.html
@@ -7231,7 +7231,7 @@ Bitcoin.Util = {
         }
     }
 </script>
-<script id="floBlockchainAPI" version="2.0.0">
+<script id="floBlockchainAPI" version="2.0.1">
     /* FLO Blockchain Operator to send/receive data from blockchain using API calls*/
     const floBlockchainAPI = {
 
@@ -7592,6 +7592,14 @@ Bitcoin.Util = {
             })
         },
 
+        getTx: function (txid) {
+            return new Promise((resolve, reject) => {
+                this.promisedAPI(`api/tx/${txid}`)
+                    .then(response => resolve(response))
+                    .catch(error => reject(error))
+            })
+        },
+
         //Read Txs of Address between from and to
         readTxs: function (addr, from, to) {
             return new Promise((resolve, reject) => {
@@ -7667,7 +7675,7 @@ Bitcoin.Util = {
         }
     }
 </script>
-<script id="compactIDB" version="2.0.0">
+<script id="compactIDB" version="2.0.1">
     /* Compact IndexedDB operations */
 
     window.indexedDB = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
@@ -7683,43 +7691,66 @@ Bitcoin.Util = {
             this.defaultDB = dbName;
         },
 
-        initDB: function (dbName, objectStores = {}, version = null, removeStores = []) {
+        upgradeDB: function (dbName, createList = null, deleteList = null) {
             return new Promise((resolve, reject) => {
-                this.defaultDB = this.defaultDB || dbName;
-                var idb = version ? indexedDB.open(dbName, version) : indexedDB.open(dbName);
-                idb.onerror = (event) => {
-                    reject("Error in opening IndexedDB!");
-                };
-                idb.onupgradeneeded = (event) => {
-                    var db = event.target.result;
-                    for (let obs in objectStores) {
-                        var objectStore = db.createObjectStore(obs, objectStores[obs].options ||
-                        {});
-                        if (objectStores[obs].indexes && typeof objectStores[obs].indexes ===
-                            'object')
-                            for (let i in objectStores[obs].indexes)
-                                objectStore.createIndex(i, i, objectStores[obs].indexes[i] || {});
+                this.getDBversion(dbName).then(version => {
+                    var idb = indexedDB.open(dbName, version + 1);
+                    idb.onerror = (event) => reject("Error in opening IndexedDB");
+                    idb.onupgradeneeded = (event) => {
+                        let db = event.target.result;
+                        if (createList instanceof Object) {
+                            if (Array.isArray(createList)) {
+                                let tmp = {}
+                                createList.forEach(o => tmp[o] = {})
+                                createList = tmp
+                            }
+                            for (let o in createList) {
+                                let obs = db.createObjectStore(o, createList[o].options ||
+                                    {});
+                                if (createList[o].indexes instanceof Object)
+                                    for (let i in createList[o].indexes)
+                                        obs.createIndex(i, i, createList[o].indexes || {});
+                            }
+                        }
+                        if (Array.isArray(deleteList))
+                            deleteList.forEach(o => db.deleteObjectStore(o));
+                        resolve('Database upgraded')
                     }
-                    if (version)
-                        removeStores.forEach(obs => db.deleteObjectStore(obs));
-                }
+                    idb.onsuccess = (event) => event.target.result.close();
+                }).catch(error => reject(error))
+            })
+        },
+
+        initDB: function (dbName, objectStores = {}) {
+            return new Promise((resolve, reject) => {
+                if (!(objectStores instanceof Object))
+                    return reject('ObjectStores must be an object or array')
+                this.defaultDB = this.defaultDB || dbName;
+                var idb = indexedDB.open(dbName);
+                idb.onerror = (event) => reject("Error in opening IndexedDB");
                 idb.onsuccess = (event) => {
                     var db = event.target.result;
-                    if (JSON.stringify(Object.values(db.objectStoreNames).sort()) === JSON
-                        .stringify(Object.keys(objectStores).sort()))
+                    let cList = Object.values(db.objectStoreNames);
+                    var obs = {},
+                        a_obs = {},
+                        d_obs = [];
+                    if (!Array.isArray(objectStores))
+                        var obs = objectStores
+                    else
+                        objectStores.forEach(o => obs[o] = {})
+                    let nList = Object.keys(obs)
+                    for (let o of nList)
+                        if (!cList.includes(o))
+                            a_obs[o] = obs[o]
+                    for (let o of cList)
+                        if (!nList.includes(o))
+                            d_obs.push(o)
+                    if (!Object.keys(a_obs).length && !d_obs.length)
                         resolve("Initiated IndexedDB");
-                    else {
-                        let removeObs = [];
-                        Object.values(db.objectStoreNames).forEach(obs => {
-                            if (obs in objectStores)
-                                delete objectStores[obs]
-                            else
-                                removeObs.push(obs)
-                        })
-                        this.initDB(dbName, objectStores, db.version + 1, removeObs)
-                            .then(result => resolve(result))
-                            .catch(error => reject(error))
-                    }
+                    else
+                        this.upgradeDB(dbName, a_obs, d_obs)
+                        .then(result => resolve(result))
+                        .catch(error => reject(error))
                     db.close();
                 }
             });
@@ -7728,7 +7759,12 @@ Bitcoin.Util = {
         openDB: function (dbName = this.defaultDB) {
             return new Promise((resolve, reject) => {
                 var idb = indexedDB.open(dbName);
-                idb.onerror = (event) => reject("Error in opening IndexedDB!");
+                idb.onerror = (event) => reject("Error in opening IndexedDB");
+                idb.onupgradeneeded = (event) => {
+                    event.target.result.close();
+                    this.deleteDB(dbName)
+                    reject("Datebase not found")
+                }
                 idb.onsuccess = (event) => resolve(event.target.result);
             });
         },
@@ -7741,6 +7777,15 @@ Bitcoin.Util = {
             });
         },
 
+        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 => {
@@ -7867,7 +7912,7 @@ Bitcoin.Util = {
         }
     }
 </script>
-<script id="floCloudAPI" version="2.0.2a">
+<script id="floCloudAPI" version="2.0.2c">
     /* FLO Cloud operations to send/request application data*/
     const floCloudAPI = {
 
@@ -8011,25 +8056,35 @@ Bitcoin.Util = {
                 }
             },
 
+            inactive: [],
             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.includes(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.push(snID)
                             reject(`${snID} is not active`)
                         }
                     }
-                    wsConn.onerror = evt => reject(`${snID} is unavailable`)
+                    wsConn.onerror = evt => {
+                        inactive.push(snID)
+                        reject(`${snID} is unavailable`)
+                    }
                 })
             },
 
             connectActive(snID, reverse = false) {
                 return new Promise((resolve, reject) => {
+                    if (this.inactive.length === this.kBucket.SNCO.length)
+                        return reject('Cloud offline')
                     if (!(snID in floGlobals.supernodes))
                         snID = this.kBucket.closestNode(snID);
                     this.connect(snID)
@@ -8068,7 +8123,7 @@ Bitcoin.Util = {
             },
 
             liveRequest: function (floID, datareq, callback) {
-                request = {
+                let request = {
                     ...datareq.request
                 };
                 const checkFilter = (v, d, r) =>
@@ -8090,15 +8145,18 @@ Bitcoin.Util = {
                             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]
-                                callback(filter, null)
+                                d = filter
                             } catch (error) {
-                                callback(null, evt.data.substring(i))
+                                e = evt.data.substring(i)
+                            } finally {
+                                callback(d, e)
                             }
                         }
                         this.liveRequest[randID] = node;
@@ -8629,7 +8687,7 @@ Bitcoin.Util = {
         }
     }
 </script>
-<script id="floDapps" version="2.0.1">
+<script id="floDapps" version="2.0.1a">
     /* General functions for FLO Dapps*/
     const floDapps = {
 
@@ -9029,14 +9087,14 @@ Bitcoin.Util = {
                     return reject("Invalid floID!")
                 compactIDB.writeData("contacts", name, floID, `floDapps#${myFloID}`).then(result => {
                     floGlobals.contacts[floID] = name;
-                    resolve(result)
+                    resolve("Contact stored")
                 }).catch(error => reject(error))
             });
         },
 
         storePubKey(floID, pubKey) {
             return new Promise((resolve, reject) => {
-                if (floID in floGlobals.pubKey)
+                if (floID in floGlobals.pubKeys)
                     return resolve("pubKey already stored")
                 if (!floCrypto.validateAddr(floID))
                     return reject("Invalid floID!")
@@ -9044,7 +9102,7 @@ Bitcoin.Util = {
                     return reject("Incorrect pubKey")
                 compactIDB.writeData("pubKeys", pubKey, floID, `floDapps#${myFloID}`).then(result => {
                     floGlobals.pubKeys[floID] = pubKey;
-                    resolve(result)
+                    resolve("pubKey stored")
                 }).catch(error => reject(error))
             });
         },
@@ -9074,8 +9132,10 @@ Bitcoin.Util = {
                 }
                 options.callback = (d, e) => {
                     for (let v in d) {
-                        if ("secret" in d[v].message)
-                            d[v].message = floCrypto.decryptData(d[v].message, myPrivKey)
+                        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]
                     }
@@ -9115,7 +9175,7 @@ Bitcoin.Util = {
 
         clearCredentials: function () {
             return new Promise((resolve, reject) => {
-                compactIDB.clearData('credentials').then(result => {
+                compactIDB.clearData('credentials', floGlobals.application).then(result => {
                     localStorage.removeItem(`${floGlobals.application}#privKey`)
                     myPrivKey = myPubKey = myFloID = undefined;
                     resolve("privKey credentials deleted!")
@@ -9123,11 +9183,11 @@ Bitcoin.Util = {
             })
         },
 
-        deleteUserData: function(credentials = false) {
+        deleteUserData: function (credentials = false) {
             return new Promise((resolve, reject) => {
                 let p = []
                 p.push(compactIDB.deleteDB(`floDapps#${myFloID}`))
-                if(credentials)
+                if (credentials)
                     p.push(this.clearCredentials())
                 Promise.all(p)
                     .then(result => resolve('User database(local) deleted'))
@@ -9135,9 +9195,9 @@ Bitcoin.Util = {
             })
         },
 
-        deleteAppData: function() {
+        deleteAppData: function () {
             return new Promise((resolve, reject) => {
-                compactIDB.deleteDB().then(result => {
+                compactIDB.deleteDB(floGlobals.application).then(result => {
                     localStorage.removeItem(`${floGlobals.application}#privKey`)
                     myPrivKey = myPubKey = myFloID = undefined;
                     resolve("App database(local) deleted")
@@ -9155,8 +9215,10 @@ Bitcoin.Util = {
                 let threshold = indexArr.length;
                 let shares = floCrypto.createShamirsSecretShares(encryptedKey, threshold, threshold)
                 let promises = [];
+                let overwriteFn = (share, index) =>
+                    compactIDB.writeData("credentials", share, index, floGlobals.application);
                 for (var i = 0; i < threshold; i++)
-                    promises.push(compactIDB.writeData("credentials", shares[i], indexArr[i]));
+                    promises.push(overwriteFn(shares[i], indexArr[i]));
                 Promise.all(promises)
                     .then(results => resolve("Private Key Secured"))
                     .catch(error => reject(error))
@@ -9186,7 +9248,7 @@ Bitcoin.Util = {
                 for (let f in filteredResult) {
                     let data = filteredResult[f]
                     try {
-                        if ("secret" in data.message && "senderPublicKeyString" in data.message) {
+                        if (data.message instanceof Object && "secret" in data.message) {
                             for (let key of decryptionKey) {
                                 try {
                                     let tmp = floCrypto.decryptData(data.message, key)
@@ -9233,14 +9295,14 @@ Bitcoin.Util = {
                         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]
-                            }
-                        })
+                        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))