Udating encoding/decoding to modern standards

1.Using TextEncoder for new encoding,and TextDecoder for decoding
2. Dual decoding in case the modern decoder fails, then retry with older decoder.

floBlockchainAPI.js

@@ -1,4 +1,4 @@
-(function (EXPORTS) { //floBlockchainAPI v3.0.1b
+(function (EXPORTS) { //floBlockchainAPI v3.1.4
     /* FLO Blockchain Operator to send/receive data from blockchain using API calls via FLO Blockbook*/
     'use strict';
     const floBlockchainAPI = EXPORTS;
@@ -7,7 +7,7 @@
         blockchain: floGlobals.blockchain,
         apiURL: {
             FLO: ['https://blockbook.ranchimall.net/'],
-            FLO_TEST: []
+            FLO_TEST: ['https://blockbook-testnet.ranchimall.net/']
         },
         sendAmt: 0.0003,
         fee: 0.0002,
@@ -15,9 +15,29 @@
         receiverID: floGlobals.adminID
     };
 
+    floBlockchainAPI.apiURL = DEFAULT.apiURL[DEFAULT.blockchain][0];
     const SATOSHI_IN_BTC = 1e8;
     const isUndefined = val => typeof val === 'undefined';
 
+    const checkIfTor = floBlockchainAPI.checkIfTor = () => {
+        return fetch('https://check.torproject.org/api/ip')
+            .then(res => res.json())
+            .then(res => {
+                return res.IsTor
+            }).catch(e => {
+                console.error(e)
+                return false
+            })
+    }
+    let isTor = false;
+    checkIfTor().then(result => {
+        isTor = result
+        if (isTor) {
+            DEFAULT.apiURL.FLO.push('http://xge4kejxl6xs4cad3u3a7dnw7idndlkn3vmyo33t3a4ctk566y65eoad.onion/')
+            DEFAULT.apiURL.FLO_TEST.push('http://fdjrsde2qhfecvx6fkgmcidwkp34bdek7jo4y2fpqatrhzxtxkk6f4ad.onion/')
+        }
+    });
+
     const util = floBlockchainAPI.util = {};
 
     util.Sat_to_FLO = value => parseFloat((value / SATOSHI_IN_BTC).toFixed(8));

floCloudAPI.js

@@ -1,4 +1,4 @@
-(function (EXPORTS) { //floCloudAPI v2.4.3a
+(function (EXPORTS) { //floCloudAPI v2.4.5a
     /* FLO Cloud operations to send/request application data*/
     'use strict';
     const floCloudAPI = EXPORTS;
@@ -195,14 +195,24 @@
     floCloudAPI.init = function startCloudProcess(nodes) {
         return new Promise((resolve, reject) => {
             try {
+                // accept only plain-ish objects
+                nodes = (nodes && typeof nodes === 'object' && !Array.isArray(nodes)) ? nodes : {};
+
                 supernodes = nodes;
+
+                // reset liveness bookkeeping for the new set
+                if (_inactive && typeof _inactive.clear === 'function') _inactive.clear();
+
+                // (re)build the bucket with current IDs
                 kBucket = new K_Bucket(DEFAULT.SNStorageID, Object.keys(supernodes));
+
                 resolve('Cloud init successful');
             } catch (error) {
                 reject(error);
             }
-        })
+        });
-    }
+    };
+
 
     Object.defineProperty(floCloudAPI, 'kBucket', {
         get: () => kBucket
@@ -227,24 +237,27 @@
 
     function ws_activeConnect(snID, reverse = false) {
         return new Promise((resolve, reject) => {
-            if (_inactive.size === kBucket.list.length)
+            // Safe guard: uninitialized kBucket, empty list, or all inactive
+            if (!kBucket || !kBucket.list || !kBucket.list.length || _inactive.size === kBucket.list.length)
                 return reject('Cloud offline');
-            if (!(snID in supernodes))
+
-                snID = kBucket.closestNode(proxyID(snID));
+            if (!(snID in supernodes)) {
+                var closest = kBucket.closestNode(proxyID(snID));
+                if (!closest) return reject('Cloud offline'); // no candidate to try
+                snID = closest;
+            }
+
             ws_connect(snID)
                 .then(node => resolve(node))
                 .catch(error => {
-                    if (reverse)
+                    var nxtNode = reverse ? kBucket.prevNode(snID) : kBucket.nextNode(snID);
-                        var nxtNode = kBucket.prevNode(snID);
+                    if (!nxtNode || nxtNode === snID) return reject('Cloud offline'); // nothing else to try
-                    else
+                    ws_activeConnect(nxtNode, reverse).then(resolve).catch(reject);
-                        var nxtNode = kBucket.nextNode(snID);
+                });
-                    ws_activeConnect(nxtNode, reverse)
+        });
-                        .then(node => resolve(node))
-                        .catch(error => reject(error))
-                })
-        })
     }
 
+
     function fetch_API(snID, data) {
         return new Promise((resolve, reject) => {
             if (_inactive.has(snID))
@@ -265,25 +278,28 @@
 
     function fetch_ActiveAPI(snID, data, reverse = false) {
         return new Promise((resolve, reject) => {
-            if (_inactive.size === kBucket.list.length)
+            // Safe guard: uninitialized kBucket, empty list, or all inactive
+            if (!kBucket || !kBucket.list || !kBucket.list.length || _inactive.size === kBucket.list.length)
                 return reject('Cloud offline');
-            if (!(snID in supernodes))
+
-                snID = kBucket.closestNode(proxyID(snID));
+            if (!(snID in supernodes)) {
+                var closest = kBucket.closestNode(proxyID(snID));
+                if (!closest) return reject('Cloud offline'); // no candidate available
+                snID = closest;
+            }
+
             fetch_API(snID, data)
-                .then(result => resolve(result))
+                .then(resolve)
                 .catch(error => {
-                    _inactive.add(snID)
+                    _inactive.add(snID);
-                    if (reverse)
+                    var nxtNode = reverse ? kBucket.prevNode(snID) : kBucket.nextNode(snID);
-                        var nxtNode = kBucket.prevNode(snID);
+                    if (!nxtNode || nxtNode === snID) return reject('Cloud offline'); // nothing else to try
-                    else
+                    fetch_ActiveAPI(nxtNode, data, reverse).then(resolve).catch(reject);
-                        var nxtNode = kBucket.nextNode(snID);
+                });
-                    fetch_ActiveAPI(nxtNode, data, reverse)
+        });
-                        .then(result => resolve(result))
-                        .catch(error => reject(error));
-                })
-        })
     }
 
+
     function singleRequest(floID, data_obj, method = "POST") {
         return new Promise((resolve, reject) => {
             let data;
@@ -374,13 +390,31 @@
 
     const util = floCloudAPI.util = {};
 
+    //Updating encoding/Decoding to modern standards
     const encodeMessage = util.encodeMessage = function (message) {
-        return btoa(unescape(encodeURIComponent(JSON.stringify(message))))
+        const bytes = new TextEncoder().encode(JSON.stringify(message));
-    }
+        let bin = "";
+        for (let i = 0; i < bytes.length; i++) bin += String.fromCharCode(bytes[i]);
+        return btoa(bin);
+    };
 
     const decodeMessage = util.decodeMessage = function (message) {
-        return JSON.parse(decodeURIComponent(escape(atob(message))))
+        try {
-    }
+            // try modern decode first
+            const bin = atob(message);
+            const bytes = new Uint8Array(bin.length);
+            for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
+            return JSON.parse(new TextDecoder().decode(bytes));
+        } catch (e1) {
+            try {
+                // fallback to legacy decode
+                return JSON.parse(decodeURIComponent(escape(atob(message))));
+            } catch (e2) {
+                // final fallback: return raw string to avoid hard crash
+                return message;
+            }
+        }
+    };
 
     const filterKey = util.filterKey = function (type, options = {}) {
         return type + (options.comment ? ':' + options.comment : '') +
@@ -468,21 +502,59 @@
 
     function storeGeneral(fk, dataSet) {
         try {
-            console.log(dataSet)
+            if (!dataSet || typeof dataSet !== "object") return;
-            if (typeof generalData[fk] !== "object")
+
-                generalData[fk] = {}
+            // Ensure containers exist
-            for (let vc in dataSet) {
+            if (typeof generalData[fk] !== "object" || generalData[fk] === null)
-                generalData[fk][vc] = dataSet[vc];
+                generalData[fk] = {};
-                if (dataSet[vc].log_time > lastVC[fk])
+            if (typeof lastVC[fk] !== "number")
-                    lastVC[fk] = dataSet[vc].log_time;
+                lastVC[fk] = 0;
+
+            // Merge data and track latest log_time
+            let updated = false;
+            let newLast = lastVC[fk];
+
+            for (const vc in dataSet) {
+                const rec = dataSet[vc];
+                // Skip bad records
+                if (!rec || typeof rec !== "object") continue;
+
+                // Assign only if changed reference (cheap check)
+                if (generalData[fk][vc] !== rec) {
+                    generalData[fk][vc] = rec;
+                    updated = true;
+                }
+                if (typeof rec.log_time === "number" && rec.log_time > newLast) {
+                    newLast = rec.log_time;
+                    updated = true;
+                }
             }
-            compactIDB.writeData("lastVC", lastVC[fk], fk)
+
-            compactIDB.writeData("generalData", generalData[fk], fk)
+            if (!updated) return; // nothing new, avoid IDB writes
+
+            lastVC[fk] = newLast;
+
+            // --- Debounce writes per fk to avoid IDB thrash ---
+            storeGeneral._pending = storeGeneral._pending || Object.create(null);
+            const pend = storeGeneral._pending;
+
+            clearTimeout(pend[fk]);
+            pend[fk] = setTimeout(() => {
+                try {
+                    // Fire-and-forget; callers don’t wait on these
+                    compactIDB.writeData("lastVC", lastVC[fk], fk);
+                    compactIDB.writeData("generalData", generalData[fk], fk);
+                } catch (e) {
+                    console.error(e);
+                }
+            }, 50);
+
         } catch (error) {
-            console.error(error)
+            console.error(error);
         }
     }
 
+
     function objectifier(data) {
         if (!Array.isArray(data))
             data = [data];
@@ -551,7 +623,7 @@
     }
 
     //request any data from supernode cloud
-    const requestApplicationData = floCloudAPI.requestApplicationData = function (type, options = {}) {
+    const _requestApplicationData = function (type, options = {}) {
         return new Promise((resolve, reject) => {
             var request = {
                 receiverID: options.receiverID || DEFAULT.adminID,
@@ -582,6 +654,17 @@
         })
     }
 
+    floCloudAPI.requestApplicationData = function (type, options = {}) {
+        return new Promise((resolve, reject) => {
+            let single_request_mode = !(options.callback instanceof Function);
+            _requestApplicationData(type, options).then(data => {
+                if (single_request_mode)
+                    resolve(objectifier(data))
+                else resolve(data);
+            }).catch(error => reject(error))
+        })
+    }
+
     /*(NEEDS UPDATE)
     //delete data from supernode cloud (received only)
     floCloudAPI.deleteApplicationData = function(vectorClocks, options = {}) {
@@ -609,49 +692,39 @@
         })
     }
     */
-    /*(NEEDS UPDATE)
+    //edit comment of data in supernode cloud (sender only)
-    //edit comment of data in supernode cloud (mutable comments only)
+    floCloudAPI.editApplicationData = function (vectorClock, comment_edit, options = {}) {
-    floCloudAPI.editApplicationData = function(vectorClock, newComment, oldData, options = {}) {
         return new Promise((resolve, reject) => {
-            let p0
+            //request the data from cloud for resigning
-            if (!oldData) {
+            let req_options = Object.assign({}, options);
-                options.atVectorClock = vectorClock;
+            req_options.atVectorClock = vectorClock;
-                options.callback = false;
+            _requestApplicationData(undefined, req_options).then(result => {
-                p0 = requestApplicationData(false, options)
+                if (!result.length)
-            } else
+                    return reject("Data not found");
-                p0 = Promise.resolve({
+                let data = result[0];
-                    vectorClock: {
+                if (data.senderID !== user.id)
-                        ...oldData
+                    return reject("Only sender can edit comment");
-                    }
+                data.comment = comment_edit;
-                })
+                let hashcontent = ["receiverID", "time", "application", "type", "message", "comment"]
-            p0.then(d => {
+                    .map(d => data[d]).join("|");
-                if (d.senderID != user.id)
+                let re_sign = user.sign(hashcontent);
-                    return reject("Invalid requestorID")
+                var request = {
-                else if (!d.comment.startsWith("EDIT:"))
+                    receiverID: options.receiverID || DEFAULT.adminID,
-                    return reject("Data immutable")
-                let data = {
                     requestorID: user.id,
-                    receiverID: d.receiverID,
+                    pubKey: user.public,
                     time: Date.now(),
-                    application: d.application,
+                    vectorClock: vectorClock,
-                    edit: {
+                    edit: comment_edit,
-                        vectorClock: vectorClock,
+                    re_sign: re_sign
-                        comment: newComment
-                    }
                 }
-                d.comment = data.edit.comment;
+                let request_hash = ["time", "vectorClock", "edit", "re_sign"].map(d => request[d]).join("|");
-                let hashcontent = ["receiverID", "time", "application", "type", "message",
+                request.sign = user.sign(request_hash);
-                        "comment"
+                singleRequest(request.receiverID, request)
-                    ]
+                    .then(result => resolve(result))
-                    .map(x => d[x]).join("|")
-                data.edit.sign = user.sign(hashcontent)
-                singleRequest(data.receiverID, data)
-                    .then(result => resolve("Data comment updated"))
                     .catch(error => reject(error))
-            })
+            }).catch(error => reject(error))
         })
     }
-    */
 
     //tag data in supernode cloud (subAdmin access only)
     floCloudAPI.tagApplicationData = function (vectorClock, tag, options = {}) {
@@ -719,11 +792,11 @@
                     storeGeneral(fk, d);
                     options.callback(d, e)
                 }
-                requestApplicationData(type, new_options)
+                _requestApplicationData(type, new_options)
                     .then(result => resolve(result))
                     .catch(error => reject(error))
             } else {
-                requestApplicationData(type, options).then(dataSet => {
+                _requestApplicationData(type, options).then(dataSet => {
                     storeGeneral(fk, objectifier(dataSet))
                     resolve(dataSet)
                 }).catch(error => reject(error))
@@ -748,7 +821,7 @@
                 }
                 delete options.callback;
             }
-            requestApplicationData(objectName, options).then(dataSet => {
+            _requestApplicationData(objectName, options).then(dataSet => {
                 updateObject(objectName, objectifier(dataSet));
                 delete options.comment;
                 options.lowerVectorClock = lastVC[objectName] + 1;
@@ -756,11 +829,11 @@
                 if (callback) {
                     let new_options = Object.create(options);
                     new_options.callback = callback;
-                    requestApplicationData(objectName, new_options)
+                    _requestApplicationData(objectName, new_options)
                         .then(result => resolve(result))
                         .catch(error => reject(error))
                 } else {
-                    requestApplicationData(objectName, options).then(dataSet => {
+                    _requestApplicationData(objectName, options).then(dataSet => {
                         updateObject(objectName, objectifier(dataSet))
                         resolve(appObjects[objectName])
                     }).catch(error => reject(error))
@@ -811,6 +884,67 @@
         })
     }
 
+    //upload file
+    floCloudAPI.uploadFile = function (fileBlob, type, options = {}) {
+        return new Promise((resolve, reject) => {
+            if (!(fileBlob instanceof File) && !(fileBlob instanceof Blob))
+                return reject("file must be instance of File/Blob");
+            fileBlob.arrayBuffer().then(arraybuf => {
+                let file_data = { type: fileBlob.type, name: fileBlob.name };
+                file_data.content = Crypto.util.bytesToBase64(new Uint8Array(arraybuf));
+                if (options.encrypt) {
+                    let encryptionKey = options.encrypt === true ?
+                        floGlobals.settings.encryptionKey : options.encrypt
+                    file_data = floCrypto.encryptData(JSON.stringify(file_data), encryptionKey)
+                }
+                sendApplicationData(file_data, type, options)
+                    .then(({ vectorClock, receiverID, type, application }) => resolve({ vectorClock, receiverID, type, application }))
+                    .catch(error => reject(error))
+            }).catch(error => reject(error))
+        })
+    }
+
+    //download file
+    floCloudAPI.downloadFile = function (vectorClock, options = {}) {
+        return new Promise((resolve, reject) => {
+            options.atVectorClock = vectorClock;
+            _requestApplicationData(options.type, options).then(result => {
+                if (!result.length)
+                    return reject("File not found");
+                result = result[0];
+                try {
+                    let file_data = decodeMessage(result.message);
+                    //file is encrypted: decryption required
+                    if (file_data instanceof Object && "secret" in file_data) {
+                        if (!options.decrypt)
+                            return reject("Data is encrypted");
+                        let decryptionKey = (options.decrypt === true) ? Crypto.AES.decrypt(user_private, aes_key) : options.decrypt;
+                        if (!Array.isArray(decryptionKey))
+                            decryptionKey = [decryptionKey];
+                        let flag = false;
+                        for (let key of decryptionKey) {
+                            try {
+                                let tmp = floCrypto.decryptData(file_data, key);
+                                file_data = JSON.parse(tmp);
+                                flag = true;
+                                break;
+                            } catch (error) { }
+                        }
+                        if (!flag)
+                            return reject("Unable to decrypt file: Invalid private key");
+                    }
+                    //reconstruct the file
+                    let arraybuf = new Uint8Array(Crypto.util.base64ToBytes(file_data.content))
+                    result.file = new File([arraybuf], file_data.name, { type: file_data.type });
+                    resolve(result)
+                } catch (error) {
+                    console.error(error);
+                    reject("Data is not a file");
+                }
+            }).catch(error => reject(error))
+        })
+    }
+
     /*
     Functions:
     findDiff(original, updatedObj) returns an object with the added, deleted and updated differences  

floDapps.js

@@ -1,4 +1,4 @@
-(function (EXPORTS) { //floDapps v2.4.0
+(function (EXPORTS) { //floDapps v2.4.1
     /* General functions for FLO Dapps*/
     'use strict';
     const floDapps = EXPORTS;
@@ -144,7 +144,7 @@
         }
     });
 
-    var subAdmins, trustedIDs, settings;
+    var subAdmins = [], trustedIDs = [], settings = {};
     Object.defineProperties(floGlobals, {
         subAdmins: {
             get: () => subAdmins
@@ -172,12 +172,7 @@
                 //general
                 lastTx: {},
                 //supernode (cloud list)
-                supernodes: {
+                supernodes: {}
-                    indexes: {
-                        uri: null,
-                        pubKey: null
-                    }
-                }
             }
             var obs_a = {
                 //login credentials
@@ -254,103 +249,154 @@
     const startUpFunctions = [];
 
     startUpFunctions.push(function readSupernodeListFromAPI() {
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve) => {
             if (!startUpOptions.cloud)
                 return resolve("No cloud for this app");
-            compactIDB.readData("lastTx", floCloudAPI.SNStorageID, DEFAULT.root).then(lastTx => {
+
-                var query_options = { sentOnly: true, pattern: floCloudAPI.SNStorageName };
+            const CLOUD_KEY = "floCloudAPI#" + floCloudAPI.SNStorageID;
-                if (typeof lastTx == 'number')  //lastTx is tx count (*backward support)
+
-                    query_options.ignoreOld = lastTx;
+            // Fallback: init from cached nodes (never reject)
-                else if (typeof lastTx == 'string') //lastTx is txid of last tx
+            const initFromCache = (tag) =>
-                    query_options.after = lastTx;
+                compactIDB.readData("supernodes", CLOUD_KEY, DEFAULT.root)
-                //fetch data from flosight
+                    .then(nodes => {
-                floBlockchainAPI.readData(floCloudAPI.SNStorageID, query_options).then(result => {
+                        nodes = nodes || {};
-                    for (var i = result.data.length - 1; i >= 0; i--) {
+                        return floCloudAPI.init(nodes)
-                        var content = JSON.parse(result.data[i])[floCloudAPI.SNStorageName];
+                            .then(r => resolve(`${tag} (from cache)\n${r}`))
-                        for (let sn in content.removeNodes)
+                            .catch(() => resolve(`${tag} (cache present, init skipped)`));
-                            compactIDB.removeData("supernodes", sn, DEFAULT.root);
-                        for (let sn in content.newNodes)
-                            compactIDB.writeData("supernodes", content.newNodes[sn], sn, DEFAULT.root);
-                        for (let sn in content.updateNodes)
-                            compactIDB.readData("supernodes", sn, DEFAULT.root).then(r => {
-                                r = r || {}
-                                r.uri = content.updateNodes[sn];
-                                compactIDB.writeData("supernodes", r, sn, DEFAULT.root);
-                            });
-                    }
-                    compactIDB.writeData("lastTx", result.lastItem, floCloudAPI.SNStorageID, DEFAULT.root);
-                    compactIDB.readAllData("supernodes", DEFAULT.root).then(nodes => {
-                        floCloudAPI.init(nodes)
-                            .then(result => resolve("Loaded Supernode list\n" + result))
-                            .catch(error => reject(error))
                     })
-                })
+                    .catch(() => resolve(`${tag} (no cache)`));
-            }).catch(error => reject(error))
+
-        })
+            compactIDB.readData("lastTx", CLOUD_KEY, DEFAULT.root).then(lastTx => {
+                const query_options = { sentOnly: true, pattern: floCloudAPI.SNStorageName };
+                if (typeof lastTx === 'number')  // backward support (tx count)
+                    query_options.ignoreOld = lastTx;
+                else if (typeof lastTx === 'string') // last txid
+                    query_options.after = lastTx;
+
+                // Try online; if it fails, fall back to cache
+                floBlockchainAPI.readData(floCloudAPI.SNStorageID, query_options).then(result => {
+                    compactIDB.readData("supernodes", CLOUD_KEY, DEFAULT.root).then(nodes => {
+                        nodes = nodes || {};
+                        for (let i = result.data.length - 1; i >= 0; i--) {
+                            const content = JSON.parse(result.data[i])[floCloudAPI.SNStorageName];
+                            if (!content || typeof content !== 'object') continue;
+                            if (content.removeNodes)
+                                for (let sn in content.removeNodes) delete nodes[sn];
+                            if (content.newNodes)
+                                for (let sn in content.newNodes) nodes[sn] = content.newNodes[sn];
+                            if (content.updateNodes)
+                                for (let sn in content.updateNodes)
+                                    if (sn in nodes) nodes[sn].uri = content.updateNodes[sn];
+                        }
+                        Promise.all([
+                            compactIDB.writeData("lastTx", result.lastItem, CLOUD_KEY, DEFAULT.root),
+                            compactIDB.writeData("supernodes", nodes, CLOUD_KEY, DEFAULT.root)
+                        ]).then(() => {
+                            floCloudAPI.init(nodes)
+                                .then(r => resolve("Loaded Supernode list\n" + r))
+                                .catch(() => resolve("Loaded Supernode list (init deferred)"));
+                        }).catch(() => resolve("Supernode list updated (persist partial)"));
+                    }).catch(() => initFromCache("Supernode list read failed"));
+                }).catch(() => initFromCache("Supernode network fetch failed"));
+            }).catch(() => initFromCache("Supernode lastTx read failed"));
+        });
     });
 
+
     startUpFunctions.push(function readAppConfigFromAPI() {
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve) => {
             if (!startUpOptions.app_config)
                 return resolve("No configs for this app");
-            compactIDB.readData("lastTx", `${DEFAULT.application}|${DEFAULT.adminID}`, DEFAULT.root).then(lastTx => {
+
-                var query_options = { sentOnly: true, pattern: DEFAULT.application };
+            // small helper: load cached directives into memory and resolve
-                if (typeof lastTx == 'number')  //lastTx is tx count (*backward support)
+            const loadFromIDB = (msg) => Promise.all([
-                    query_options.ignoreOld = lastTx;
+                compactIDB.readAllData("subAdmins"),
-                else if (typeof lastTx == 'string') //lastTx is txid of last tx
+                compactIDB.readAllData("trustedIDs"),
-                    query_options.after = lastTx;
+                compactIDB.readAllData("settings")
-                //fetch data from flosight               
+            ]).then(([sub, trust, set]) => {
+                subAdmins  = Object.keys(sub || {});   // arrays of IDs
+                trustedIDs = Object.keys(trust || {});
+                settings   = set || {};
+                resolve(msg);
+            }).catch(() => {
+                // safe defaults if cache missing
+                subAdmins = []; trustedIDs = []; settings = {};
+                resolve(msg + " (no local cache)");
+            });
+
+            // If cloud is disabled, use cached config and move on
+            if (!startUpOptions.cloud)
+                return loadFromIDB("Read app configuration from local cache (offline)");
+
+            const lastKey = `${DEFAULT.application}|${DEFAULT.adminID}`;
+
+            // Try to read lastTx; on failure, just use cache (don’t block startup)
+            compactIDB.readData("lastTx", lastKey, DEFAULT.root).then(lastTx => {
+                const query_options = { sentOnly: true, pattern: DEFAULT.application };
+                if (typeof lastTx === 'number') query_options.ignoreOld = lastTx;
+                else if (typeof lastTx === 'string') query_options.after = lastTx;
+
+                // Fetch deltas from chain; on failure, fall back to cache
                 floBlockchainAPI.readData(DEFAULT.adminID, query_options).then(result => {
-                    for (var i = result.data.length - 1; i >= 0; i--) {
+                    for (let i = result.data.length - 1; i >= 0; i--) {
-                        var content = JSON.parse(result.data[i])[DEFAULT.application];
+                        const content = JSON.parse(result.data[i])[DEFAULT.application];
-                        if (!content || typeof content !== "object")
+                        if (!content || typeof content !== "object") continue;
-                            continue;
+
                         if (Array.isArray(content.removeSubAdmin))
-                            for (var j = 0; j < content.removeSubAdmin.length; j++)
+                            for (let 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++)
+                            for (let k = 0; k < content.addSubAdmin.length; k++)
                                 compactIDB.writeData("subAdmins", true, content.addSubAdmin[k]);
+
                         if (Array.isArray(content.removeTrustedID))
-                            for (var j = 0; j < content.removeTrustedID.length; j++)
+                            for (let j = 0; j < content.removeTrustedID.length; j++)
                                 compactIDB.removeData("trustedIDs", content.removeTrustedID[j]);
+
                         if (Array.isArray(content.addTrustedID))
-                            for (var k = 0; k < content.addTrustedID.length; k++)
+                            for (let k = 0; k < content.addTrustedID.length; k++)
                                 compactIDB.writeData("trustedIDs", true, content.addTrustedID[k]);
+
                         if (content.settings)
                             for (let l in content.settings)
-                                compactIDB.writeData("settings", content.settings[l], l)
+                                compactIDB.writeData("settings", content.settings[l], l);
                     }
-                    compactIDB.writeData("lastTx", result.lastItem, `${DEFAULT.application}|${DEFAULT.adminID}`, DEFAULT.root);
+
-                    compactIDB.readAllData("subAdmins").then(result => {
+                    // persist last item marker (best effort)
-                        subAdmins = Object.keys(result);
+                    compactIDB.writeData("lastTx", result.lastItem, lastKey, DEFAULT.root).catch(() => {});
-                        compactIDB.readAllData("trustedIDs").then(result => {
+
-                            trustedIDs = Object.keys(result);
+                    // load fresh values from IDB into memory and finish
-                            compactIDB.readAllData("settings").then(result => {
+                    loadFromIDB("Read app configuration from blockchain");
-                                settings = result;
+                }).catch(() => {
-                                resolve("Read app configuration from blockchain");
+                    // network failed → boot from cache
-                            })
+                    loadFromIDB("Read app configuration from local cache (network fail)");
-                        })
+                });
-                    })
+            }).catch(() => {
-                })
+                // couldn't read lastTx → still boot from cache
-            }).catch(error => reject(error))
+                loadFromIDB("Read app configuration from local cache (no lastTx)");
-        })
+            });
+        });
     });
 
+
     startUpFunctions.push(function loadDataFromAppIDB() {
         return new Promise((resolve, reject) => {
-            if (!startUpOptions.cloud)
+            const loadData = ["appObjects", "generalData", "lastVC"];
-                return resolve("No cloud for this app");
+
-            var loadData = ["appObjects", "generalData", "lastVC"]
+            // If cloud is disabled AND no IDB stores are expected, skip early
-            var promises = []
+            if (!startUpOptions.cloud && (!initIndexedDB.appObs || Object.keys(initIndexedDB.appObs).length === 0))
-            for (var i = 0; i < loadData.length; i++)
+                return resolve("No cloud and no local data to load");
-                promises[i] = compactIDB.readAllData(loadData[i])
+
-            Promise.all(promises).then(results => {
+            // Otherwise, read from IDB
-                for (var i = 0; i < loadData.length; i++)
+            Promise.all(loadData.map(item => compactIDB.readAllData(item)))
-                    floGlobals[loadData[i]] = results[i]
+                .then(results => {
-                resolve("Loaded Data from app IDB")
+                    for (let i = 0; i < loadData.length; i++)
-            }).catch(error => reject(error))
+                        floGlobals[loadData[i]] = results[i];
-        })
+                    resolve("Loaded Data from app IDB");
+                })
+                .catch(error => reject(error));
+        });
     });
 
     var keyInput = type => new Promise((resolve, reject) => {

index.html

@@ -26,14 +26,14 @@
 
             })();
     </script>
-    <script src="lib.js"></script>
+    <script src="lib.js" type="text/javascript"></script>
-    <script src="floCrypto.js"></script>
+    <script src="floCrypto.js" type="text/javascript"></script>
-    <script src="btcOperator.js"></script>
+    <script src="btcOperator.js" type="text/javascript"></script>
-    <script src="floBlockchainAPI.js"></script>
+    <script src="floBlockchainAPI.js" type="text/javascript"></script>
-    <script src="floTokenAPI.js"></script>
+    <script src="floTokenAPI.js" type="text/javascript"></script>
-    <script src="compactIDB.js"></script>
+    <script src="compactIDB.js" type="text/javascript"></script>
-    <script src="floCloudAPI.js"></script>
+    <script src="floCloudAPI.js" type="text/javascript"></script>
-    <script src="floDapps.js"></script>
+    <script src="floDapps.js" type="text/javascript"></script>
     <script id="onLoadStartUp">
         function onLoadStartUp() {
             if (window.quick) return;