diff --git a/standard_Operations.html b/standard_Operations.html
index 0dc345a..089e552 100644
--- a/standard_Operations.html
+++ b/standard_Operations.html
@@ -7667,7 +7667,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 +7683,65 @@ 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 +7750,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 +7768,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 => {