diff --git a/.config b/.config
new file mode 100644
index 0000000..a66b0d8
--- /dev/null
+++ b/.config
@@ -0,0 +1,3 @@
+SERVER_PWD=<server_password>
+BROWSER=firefox
+PORT=7130
diff --git a/README.md b/README.md
index 0115093..f823965 100644
--- a/README.md
+++ b/README.md
@@ -1,80 +1,23 @@
-# Standard_Operations
- Standard operations required for FLO Crypto, Blockchain API, Supernode WS, IndexedDB 
 
-This template contains standard operations that can be used for the following:
-1. FLO Globals
-2. FLO Crypto  Operations 
-3. FLO Blockchain API Operations
-4. FLO SuperNode Websocket Operations
-5. compact IndexedDB Operations
+# SuperNodeStorage
+FLO Supernode Storage is a Cloud Storage progam for FLO Dapps
 
-## FLO Globals 
-`floGlobals` object contains the global variables and constants required for the operations.  Make sure to add this object before any other scripts.
-`floGlobals` contains the following properties :
-1. `blockchain` : Indicates the blockchain (`"FLO"` or `"FLO_TEST"`).
-2. `apiURL` : Indicates the URL for blockchain API calls. 
-3. `adminID` : Indicates the master admin FLO ID for the project.
-4. `sendAmt` :  Indicates the default flo amount to be sent while sending transactions into the blockchain
-5. `fee` : Indicates the default fee amount to be deduced while sending transactions into the blockchain
-6. `supernodes` : Holder for the supernode list. Can be updated in runtime while retriving data from blockchain using API. Stored in the Object format,
+## Installation
+1. Download or clone the [repo](https://github.com/ranchimall/SuperNodeStorage):
 
-		{
-			<supernodeFLOID> : {
-				uri : <supernodeURI>
-				...(otherProperties)
-				}
-			...(Other Supernodes)
-		}
+		git clone https://github.com/ranchimall/SuperNodeStorage
+2. Add a strong <server_password>  in `.config` file
+3. Change other configurations (if needed)
+4. Host and publish the domain name or IP with port
 
-## FLO Crypto Operations
-`floCrypto` operations can be used to perform blockchain-cryptography methods. `floCrypto` operations are synchronized and return a value. Contains the following Operations.
-#### Generate New FLO ID pair
-	floCrypto.generateNewID()
- `generateNewID`  generates a new flo ID and returns private-key, public-key and floID
+## Usage
+1. Start the app using the following command in terminal. The server WSS will be started and the supernode html-js will be opened in the browser.
 
-#### 	Calculate Public Key Hex
-`getPubKeyHex` returns public-key from given private-key
-	 floCrypto.getPubKeyHex(privateKey)
-1. privateKey - private key in WIF format (Hex) 
+		./start_supernode.sh
+2.  (Only for first time login) Enter the <server_password> and <private_key> when prompted
 
-#### 	Calculate FLO ID
-	 floCrypto.getFloIDfromPubkeyHex(publicKey)
-`getFloIDfromPubkeyHex` returns flo-ID from public-key
-1. publicKey - public key hex value 
+The Supernode storage will automatically start
 
-#### 	Verify Private Key
-	 floCrypto.verifyPrivKey(privateKey, pubKey_floID, *isfloID)
-`verifyPrivKey` verify the private-key for the given public-key or flo-ID
-1. privateKey - private key in WIF format (Hex) 
-2. pubKey_floID - public Key or flo ID
-3. isfloID - boolean value (true - compare as flo ID, false - compare as public key) (optional, default is true)
+NOTE: The <server_password> and <private_key> will be stored securedly in IndexedDB of the browser
 
-#### 	Validate FLO ID
-	 floCrypto.validateAddr(floID)
-`validateAddr` check if the given Address is valid or not
-1. floID - flo ID to validate 
-
-#### 	Data Encryption
-	 floCrypto.encryptData(data, publicKey)
-`encryptData` encrypts the given data using public-key
-1. data - data to encrypt
-2. publicKey - public key of the recipient
-
-#### 	Data Decryption
-	 floCrypto.decryptData(data, privateKey)
-`decryptData` decrypts the given data using private-key
-1. data - encrypted data to decrypt (Object that was returned from encryptData)
-2. privateKey - private key of the recipient
-
-#### 	Sign Data
-	 floCrypto.signData(data, privateKey)
-`signData` signs the data using the private key
-1. data - data to sign
-2. privateKey - private key of the signer
-
-####  Verify Signature
-	 floCrypto.decryptData(data, signature, publicKey)
-`decryptData` verifies signatue of the data using public-key
-1. data - data of the given signature
-2. signature - signature of the data
-3. publicKey - public key of the signer
+NOTE: Users may add `start_supernode` to bootup process to automatically start the supernode during boot up
diff --git a/index.html b/app/index.html
similarity index 77%
rename from index.html
rename to app/index.html
index 20dbaa2..203cb36 100644
--- a/index.html
+++ b/app/index.html
@@ -22,17 +22,24 @@
 
     //Required for blockchain API operators
     apiURL: {
-      FLO: 'https://livenet.flocha.in',
-      FLO_TEST: 'https://testnet-flosight.duckdns.org'
+      FLO: ['https://explorer.mediciland.com/', 'https://livenet.flocha.in/', 'https://flosight.duckdns.org/', 'http://livenet-explorer.floexperiments.com'],
+      FLO_TEST: ['https://testnet-flosight.duckdns.org', 'https://testnet.flocha.in/']
     },
     adminID: "FEzk75EGMPEQMrCuPosGiwuK162hcEu49E",
+    refreshDelay: 3600000,
     //sendAmt: 0.001,
     //fee: 0.0005,
 
     //Required for Supernode operations
     supernodes: {}, //each supnernode must be stored as floID : {uri:<uri>,pubKey:<publicKey>}
-    storageList : ["General"],
-    defaultStorage : "General"
+    diskList : ["General"],
+    defaultDisk : "General",
+    applicationList:{},
+    appSubAdmins:{},
+    serveList : [],
+    storedList : [],
+    supernodeConfig : {},
+    backupNodes : []
   }
 </script>
 
@@ -40,6 +47,8 @@
     <h1>SuperNode Storage</h1>
 
 <script>
+    //All util libraries required for Standard operations (DO NOT EDIT ANY)
+
     /*!
     * Crypto-JS v2.5.4  Crypto.js
     * http://code.google.com/p/crypto-js/
@@ -4700,6 +4709,579 @@
             return true;
         }
     };
+
+    // secrets.js - by Alexander Stetsyuk - released under MIT License
+    (function (exports, global) {
+            var defaults = {
+                bits: 8, // default number of bits
+                radix: 16, // work with HEX by default
+                minBits: 3,
+                maxBits: 20, // this permits 1,048,575 shares, though going this high is NOT recommended in JS!
+
+                bytesPerChar: 2,
+                maxBytesPerChar: 6, // Math.pow(256,7) > Math.pow(2,53)
+
+                // Primitive polynomials (in decimal form) for Galois Fields GF(2^n), for 2 <= n <= 30
+                // The index of each term in the array corresponds to the n for that polynomial
+                // i.e. to get the polynomial for n=16, use primitivePolynomials[16]
+                primitivePolynomials: [null, null, 1, 3, 3, 5, 3, 3, 29, 17, 9, 5, 83, 27, 43, 3, 45, 9, 39, 39,
+                    9, 5, 3, 33, 27, 9, 71, 39, 9, 5, 83
+                ],
+
+                // warning for insecure PRNG
+                warning: 'WARNING:\nA secure random number generator was not found.\nUsing Math.random(), which is NOT cryptographically strong!'
+            };
+
+            // Protected settings object
+            var config = {};
+
+            /** @expose **/
+            exports.getConfig = function () {
+                return {
+                    'bits': config.bits,
+                    'unsafePRNG': config.unsafePRNG
+                };
+            };
+
+            function init(bits) {
+                if (bits && (typeof bits !== 'number' || bits % 1 !== 0 || bits < defaults.minBits || bits >
+                        defaults.maxBits)) {
+                    throw new Error('Number of bits must be an integer between ' + defaults.minBits + ' and ' +
+                        defaults.maxBits + ', inclusive.')
+                }
+
+                config.radix = defaults.radix;
+                config.bits = bits || defaults.bits;
+                config.size = Math.pow(2, config.bits);
+                config.max = config.size - 1;
+
+                // Construct the exp and log tables for multiplication.
+                var logs = [],
+                    exps = [],
+                    x = 1,
+                    primitive = defaults.primitivePolynomials[config.bits];
+                for (var i = 0; i < config.size; i++) {
+                    exps[i] = x;
+                    logs[x] = i;
+                    x <<= 1;
+                    if (x >= config.size) {
+                        x ^= primitive;
+                        x &= config.max;
+                    }
+                }
+
+                config.logs = logs;
+                config.exps = exps;
+            };
+
+            /** @expose **/
+            exports.init = init;
+
+            function isInited() {
+                if (!config.bits || !config.size || !config.max || !config.logs || !config.exps || config.logs.length !==
+                    config.size || config.exps.length !== config.size) {
+                    return false;
+                }
+                return true;
+            };
+
+            // Returns a pseudo-random number generator of the form function(bits){}
+            // which should output a random string of 1's and 0's of length `bits`
+            function getRNG() {
+                var randomBits, crypto;
+
+                function construct(bits, arr, radix, size) {
+                    var str = '',
+                        i = 0,
+                        len = arr.length - 1;
+                    while (i < len || (str.length < bits)) {
+                        str += padLeft(parseInt(arr[i], radix).toString(2), size);
+                        i++;
+                    }
+                    str = str.substr(-bits);
+                    if ((str.match(/0/g) || []).length === str.length) { // all zeros?
+                        return null;
+                    } else {
+                        return str;
+                    }
+                }
+
+                // node.js crypto.randomBytes()
+                if (typeof require === 'function' && (crypto = require('crypto')) && (randomBits = crypto[
+                        'randomBytes'])) {
+                    return function (bits) {
+                        var bytes = Math.ceil(bits / 8),
+                            str = null;
+
+                        while (str === null) {
+                            str = construct(bits, randomBits(bytes).toString('hex'), 16, 4);
+                        }
+                        return str;
+                    }
+                }
+
+                // browsers with window.crypto.getRandomValues()
+                if (global['crypto'] && typeof global['crypto']['getRandomValues'] === 'function' && typeof global[
+                        'Uint32Array'] === 'function') {
+                    crypto = global['crypto'];
+                    return function (bits) {
+                        var elems = Math.ceil(bits / 32),
+                            str = null,
+                            arr = new global['Uint32Array'](elems);
+
+                        while (str === null) {
+                            crypto['getRandomValues'](arr);
+                            str = construct(bits, arr, 10, 32);
+                        }
+
+                        return str;
+                    }
+                }
+
+                // A totally insecure RNG!!! (except in Safari)
+                // Will produce a warning every time it is called.
+                config.unsafePRNG = true;
+                warn();
+
+                var bitsPerNum = 32;
+                var max = Math.pow(2, bitsPerNum) - 1;
+                return function (bits) {
+                    var elems = Math.ceil(bits / bitsPerNum);
+                    var arr = [],
+                        str = null;
+                    while (str === null) {
+                        for (var i = 0; i < elems; i++) {
+                            arr[i] = Math.floor(Math.random() * max + 1);
+                        }
+                        str = construct(bits, arr, 10, bitsPerNum);
+                    }
+                    return str;
+                };
+            };
+
+            // Warn about using insecure rng.
+            // Called when Math.random() is being used.
+            function warn() {
+                global['console']['warn'](defaults.warning);
+                if (typeof global['alert'] === 'function' && config.alert) {
+                    global['alert'](defaults.warning);
+                }
+            }
+
+            // Set the PRNG to use. If no RNG function is supplied, pick a default using getRNG()
+            /** @expose **/
+            exports.setRNG = function (rng, alert) {
+                if (!isInited()) {
+                    this.init();
+                }
+                config.unsafePRNG = false;
+                rng = rng || getRNG();
+
+                // test the RNG (5 times)
+                if (typeof rng !== 'function' || typeof rng(config.bits) !== 'string' || !parseInt(rng(config.bits),
+                        2) || rng(config.bits).length > config.bits || rng(config.bits).length < config.bits) {
+                    throw new Error(
+                        "Random number generator is invalid. Supply an RNG of the form function(bits){} that returns a string containing 'bits' number of random 1's and 0's."
+                    )
+                } else {
+                    config.rng = rng;
+                }
+                config.alert = !!alert;
+
+                return !!config.unsafePRNG;
+            };
+
+            function isSetRNG() {
+                return typeof config.rng === 'function';
+            };
+
+            // Generates a random bits-length number string using the PRNG
+            /** @expose **/
+            exports.random = function (bits) {
+                if (!isSetRNG()) {
+                    this.setRNG();
+                }
+
+                if (typeof bits !== 'number' || bits % 1 !== 0 || bits < 2) {
+                    throw new Error('Number of bits must be an integer greater than 1.')
+                }
+
+                if (config.unsafePRNG) {
+                    warn();
+                }
+                return bin2hex(config.rng(bits));
+            }
+
+            // Divides a `secret` number String str expressed in radix `inputRadix` (optional, default 16)
+            // into `numShares` shares, each expressed in radix `outputRadix` (optional, default to `inputRadix`),
+            // requiring `threshold` number of shares to reconstruct the secret.
+            // Optionally, zero-pads the secret to a length that is a multiple of padLength before sharing.
+            /** @expose **/
+            exports.share = function (secret, numShares, threshold, padLength, withoutPrefix) {
+                if (!isInited()) {
+                    this.init();
+                }
+                if (!isSetRNG()) {
+                    this.setRNG();
+                }
+
+                padLength = padLength || 0;
+
+                if (typeof secret !== 'string') {
+                    throw new Error('Secret must be a string.');
+                }
+                if (typeof numShares !== 'number' || numShares % 1 !== 0 || numShares < 2) {
+                    throw new Error('Number of shares must be an integer between 2 and 2^bits-1 (' + config.max +
+                        '), inclusive.')
+                }
+                if (numShares > config.max) {
+                    var neededBits = Math.ceil(Math.log(numShares + 1) / Math.LN2);
+                    throw new Error('Number of shares must be an integer between 2 and 2^bits-1 (' + config.max +
+                        '), inclusive. To create ' + numShares + ' shares, use at least ' + neededBits +
+                        ' bits.')
+                }
+                if (typeof threshold !== 'number' || threshold % 1 !== 0 || threshold < 2) {
+                    throw new Error('Threshold number of shares must be an integer between 2 and 2^bits-1 (' +
+                        config.max + '), inclusive.');
+                }
+                if (threshold > config.max) {
+                    var neededBits = Math.ceil(Math.log(threshold + 1) / Math.LN2);
+                    throw new Error('Threshold number of shares must be an integer between 2 and 2^bits-1 (' +
+                        config.max + '), inclusive.  To use a threshold of ' + threshold +
+                        ', use at least ' + neededBits + ' bits.');
+                }
+                if (typeof padLength !== 'number' || padLength % 1 !== 0) {
+                    throw new Error('Zero-pad length must be an integer greater than 1.');
+                }
+
+                if (config.unsafePRNG) {
+                    warn();
+                }
+
+                secret = '1' + hex2bin(secret); // append a 1 so that we can preserve the correct number of leading zeros in our secret
+                secret = split(secret, padLength);
+                var x = new Array(numShares),
+                    y = new Array(numShares);
+                for (var i = 0, len = secret.length; i < len; i++) {
+                    var subShares = this._getShares(secret[i], numShares, threshold);
+                    for (var j = 0; j < numShares; j++) {
+                        x[j] = x[j] || subShares[j].x.toString(config.radix);
+                        y[j] = padLeft(subShares[j].y.toString(2)) + (y[j] ? y[j] : '');
+                    }
+                }
+                var padding = config.max.toString(config.radix).length;
+                if (withoutPrefix) {
+                    for (var i = 0; i < numShares; i++) {
+                        x[i] = bin2hex(y[i]);
+                    }
+                } else {
+                    for (var i = 0; i < numShares; i++) {
+                        x[i] = config.bits.toString(36).toUpperCase() + padLeft(x[i], padding) + bin2hex(y[i]);
+                    }
+                }
+
+                return x;
+            };
+
+            // This is the basic polynomial generation and evaluation function
+            // for a `config.bits`-length secret (NOT an arbitrary length)
+            // Note: no error-checking at this stage! If `secrets` is NOT
+            // a NUMBER less than 2^bits-1, the output will be incorrect!
+            /** @expose **/
+            exports._getShares = function (secret, numShares, threshold) {
+                var shares = [];
+                var coeffs = [secret];
+
+                for (var i = 1; i < threshold; i++) {
+                    coeffs[i] = parseInt(config.rng(config.bits), 2);
+                }
+                for (var i = 1, len = numShares + 1; i < len; i++) {
+                    shares[i - 1] = {
+                        x: i,
+                        y: horner(i, coeffs)
+                    }
+                }
+                return shares;
+            };
+
+            // Polynomial evaluation at `x` using Horner's Method
+            // TODO: this can possibly be sped up using other methods
+            // NOTE: fx=fx * x + coeff[i] ->  exp(log(fx) + log(x)) + coeff[i],
+            //       so if fx===0, just set fx to coeff[i] because
+            //       using the exp/log form will result in incorrect value
+            function horner(x, coeffs) {
+                var logx = config.logs[x];
+                var fx = 0;
+                for (var i = coeffs.length - 1; i >= 0; i--) {
+                    if (fx === 0) {
+                        fx = coeffs[i];
+                        continue;
+                    }
+                    fx = config.exps[(logx + config.logs[fx]) % config.max] ^ coeffs[i];
+                }
+                return fx;
+            };
+
+            function inArray(arr, val) {
+                for (var i = 0, len = arr.length; i < len; i++) {
+                    if (arr[i] === val) {
+                        return true;
+                    }
+                }
+                return false;
+            };
+
+            function processShare(share) {
+
+                var bits = parseInt(share[0], 36);
+                if (bits && (typeof bits !== 'number' || bits % 1 !== 0 || bits < defaults.minBits || bits >
+                        defaults.maxBits)) {
+                    throw new Error('Number of bits must be an integer between ' + defaults.minBits + ' and ' +
+                        defaults.maxBits + ', inclusive.')
+                }
+
+                var max = Math.pow(2, bits) - 1;
+                var idLength = max.toString(config.radix).length;
+
+                var id = parseInt(share.substr(1, idLength), config.radix);
+                if (typeof id !== 'number' || id % 1 !== 0 || id < 1 || id > max) {
+                    throw new Error('Share id must be an integer between 1 and ' + config.max + ', inclusive.');
+                }
+                share = share.substr(idLength + 1);
+                if (!share.length) {
+                    throw new Error('Invalid share: zero-length share.')
+                }
+                return {
+                    'bits': bits,
+                    'id': id,
+                    'value': share
+                };
+            };
+
+            /** @expose **/
+            exports._processShare = processShare;
+
+            // Protected method that evaluates the Lagrange interpolation
+            // polynomial at x=`at` for individual config.bits-length
+            // segments of each share in the `shares` Array.
+            // Each share is expressed in base `inputRadix`. The output
+            // is expressed in base `outputRadix'
+            function combine(at, shares) {
+                var setBits, share, x = [],
+                    y = [],
+                    result = '',
+                    idx;
+
+                for (var i = 0, len = shares.length; i < len; i++) {
+                    share = processShare(shares[i]);
+                    if (typeof setBits === 'undefined') {
+                        setBits = share['bits'];
+                    } else if (share['bits'] !== setBits) {
+                        throw new Error('Mismatched shares: Different bit settings.')
+                    }
+
+                    if (config.bits !== setBits) {
+                        init(setBits);
+                    }
+
+                    if (inArray(x, share['id'])) { // repeated x value?
+                        continue;
+                    }
+
+                    idx = x.push(share['id']) - 1;
+                    share = split(hex2bin(share['value']));
+                    for (var j = 0, len2 = share.length; j < len2; j++) {
+                        y[j] = y[j] || [];
+                        y[j][idx] = share[j];
+                    }
+                }
+
+                for (var i = 0, len = y.length; i < len; i++) {
+                    result = padLeft(lagrange(at, x, y[i]).toString(2)) + result;
+                }
+
+                if (at === 0) { // reconstructing the secret
+                    var idx = result.indexOf('1'); //find the first 1
+                    return bin2hex(result.slice(idx + 1));
+                } else { // generating a new share
+                    return bin2hex(result);
+                }
+            };
+
+            // Combine `shares` Array into the original secret
+            /** @expose **/
+            exports.combine = function (shares) {
+                return combine(0, shares);
+            };
+
+            // Generate a new share with id `id` (a number between 1 and 2^bits-1)
+            // `id` can be a Number or a String in the default radix (16)
+            /** @expose **/
+            exports.newShare = function (id, shares) {
+                if (typeof id === 'string') {
+                    id = parseInt(id, config.radix);
+                }
+
+                var share = processShare(shares[0]);
+                var max = Math.pow(2, share['bits']) - 1;
+
+                if (typeof id !== 'number' || id % 1 !== 0 || id < 1 || id > max) {
+                    throw new Error('Share id must be an integer between 1 and ' + config.max + ', inclusive.');
+                }
+
+                var padding = max.toString(config.radix).length;
+                return config.bits.toString(36).toUpperCase() + padLeft(id.toString(config.radix), padding) +
+                    combine(id, shares);
+            };
+
+            // Evaluate the Lagrange interpolation polynomial at x = `at`
+            // using x and y Arrays that are of the same length, with
+            // corresponding elements constituting points on the polynomial.
+            function lagrange(at, x, y) {
+                var sum = 0,
+                    product,
+                    i, j;
+
+                for (var i = 0, len = x.length; i < len; i++) {
+                    if (!y[i]) {
+                        continue;
+                    }
+
+                    product = config.logs[y[i]];
+                    for (var j = 0; j < len; j++) {
+                        if (i === j) {
+                            continue;
+                        }
+                        if (at === x[j]) { // happens when computing a share that is in the list of shares used to compute it
+                            product = -1; // fix for a zero product term, after which the sum should be sum^0 = sum, not sum^1
+                            break;
+                        }
+                        product = (product + config.logs[at ^ x[j]] - config.logs[x[i] ^ x[j]] + config.max /* to make sure it's not negative */ ) %
+                            config.max;
+                    }
+
+                    sum = product === -1 ? sum : sum ^ config.exps[product]; // though exps[-1]= undefined and undefined ^ anything = anything in chrome, this behavior may not hold everywhere, so do the check
+                }
+                return sum;
+            };
+
+            /** @expose **/
+            exports._lagrange = lagrange;
+
+            // Splits a number string `bits`-length segments, after first
+            // optionally zero-padding it to a length that is a multiple of `padLength.
+            // Returns array of integers (each less than 2^bits-1), with each element
+            // representing a `bits`-length segment of the input string from right to left,
+            // i.e. parts[0] represents the right-most `bits`-length segment of the input string.
+            function split(str, padLength) {
+                if (padLength) {
+                    str = padLeft(str, padLength)
+                }
+                var parts = [];
+                for (var i = str.length; i > config.bits; i -= config.bits) {
+                    parts.push(parseInt(str.slice(i - config.bits, i), 2));
+                }
+                parts.push(parseInt(str.slice(0, i), 2));
+                return parts;
+            };
+
+            // Pads a string `str` with zeros on the left so that its length is a multiple of `bits`
+            function padLeft(str, bits) {
+                bits = bits || config.bits
+                var missing = str.length % bits;
+                return (missing ? new Array(bits - missing + 1).join('0') : '') + str;
+            };
+
+            function hex2bin(str) {
+                var bin = '',
+                    num;
+                for (var i = str.length - 1; i >= 0; i--) {
+                    num = parseInt(str[i], 16)
+                    if (isNaN(num)) {
+                        throw new Error('Invalid hex character.')
+                    }
+                    bin = padLeft(num.toString(2), 4) + bin;
+                }
+                return bin;
+            }
+
+            function bin2hex(str) {
+                var hex = '',
+                    num;
+                str = padLeft(str, 4);
+                for (var i = str.length; i >= 4; i -= 4) {
+                    num = parseInt(str.slice(i - 4, i), 2);
+                    if (isNaN(num)) {
+                        throw new Error('Invalid binary character.')
+                    }
+                    hex = num.toString(16) + hex;
+                }
+                return hex;
+            }
+
+            // Converts a given UTF16 character string to the HEX representation.
+            // Each character of the input string is represented by
+            // `bytesPerChar` bytes in the output string.
+            /** @expose **/
+            exports.str2hex = function (str, bytesPerChar) {
+                if (typeof str !== 'string') {
+                    throw new Error('Input must be a character string.');
+                }
+                bytesPerChar = bytesPerChar || defaults.bytesPerChar;
+
+                if (typeof bytesPerChar !== 'number' || bytesPerChar % 1 !== 0 || bytesPerChar < 1 ||
+                    bytesPerChar > defaults.maxBytesPerChar) {
+                    throw new Error('Bytes per character must be an integer between 1 and ' + defaults.maxBytesPerChar +
+                        ', inclusive.')
+                }
+
+                var hexChars = 2 * bytesPerChar;
+                var max = Math.pow(16, hexChars) - 1;
+                var out = '',
+                    num;
+                for (var i = 0, len = str.length; i < len; i++) {
+                    num = str[i].charCodeAt();
+                    if (isNaN(num)) {
+                        throw new Error('Invalid character: ' + str[i]);
+                    } else if (num > max) {
+                        var neededBytes = Math.ceil(Math.log(num + 1) / Math.log(256));
+                        throw new Error('Invalid character code (' + num +
+                            '). Maximum allowable is 256^bytes-1 (' + max +
+                            '). To convert this character, use at least ' + neededBytes + ' bytes.')
+                    } else {
+                        out = padLeft(num.toString(16), hexChars) + out;
+                    }
+                }
+                return out;
+            };
+
+            // Converts a given HEX number string to a UTF16 character string.
+            /** @expose **/
+            exports.hex2str = function (str, bytesPerChar) {
+                if (typeof str !== 'string') {
+                    throw new Error('Input must be a hexadecimal string.');
+                }
+                bytesPerChar = bytesPerChar || defaults.bytesPerChar;
+
+                if (typeof bytesPerChar !== 'number' || bytesPerChar % 1 !== 0 || bytesPerChar < 1 ||
+                    bytesPerChar > defaults.maxBytesPerChar) {
+                    throw new Error('Bytes per character must be an integer between 1 and ' + defaults.maxBytesPerChar +
+                        ', inclusive.')
+                }
+
+                var hexChars = 2 * bytesPerChar;
+                var out = '';
+                str = padLeft(str, hexChars);
+                for (var i = 0, len = str.length; i < len; i += hexChars) {
+                    out = String.fromCharCode(parseInt(str.slice(i, i + hexChars), 16)) + out;
+                }
+                return out;
+            };
+
+            // by default, initialize without an RNG
+            exports.init();
+        })(typeof module !== 'undefined' && module['exports'] ? module['exports'] : (window['shamirSecretShare'] = {}),
+            typeof global !== 'undefined' ? global : window);
 </script>
 
 <script>
@@ -4770,6 +5352,25 @@
       return x.modPow(BigInteger("3"), p).add(BigInteger("7")).mod(p).modPow(exp, p)
     },
 
+    //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 = false) {
+        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;
+    },
+
     getUncompressedPublicKey: function (compressedPublicKey) {
 
       const p = this.p;
@@ -4977,6 +5578,36 @@
       } catch {
         return false;
       }
+    },
+
+    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
+        }
+    },
+
+    verifyShamirsSecret: function (sharesArray, str) {
+        return (str && this.retrieveShamirSecret(sharesArray) === str)
+    },
+
+    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
+        }
     }
   }
 </script>
@@ -4984,42 +5615,66 @@
   /* FLO Blockchain Operator to send/receive data from blockchain using API calls*/
   const floBlockchainAPI = {
 
-    //Promised AJAX function to get data from API
-    promisedAJAX: function (method, uri) {
+    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)
+                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));
+                    })
+                }
+            })
+        }
+    },
+
+    //Promised function to get data from API
+    promisedAPI: function (apicall) {
       return new Promise((resolve, reject) => {
-        var request = new XMLHttpRequest();
-        var url = `${floGlobals.apiURL[floGlobals.blockchain]}/${uri}`;
-        console.log(url)
-        request.open(method, url, true);
-        request.onload = (evt) => {
-          if (request.readyState == 4 && request.status == 200)
-            resolve(request.response);
-          else
-            reject(request.response);
-        };
-        request.send();
+        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.promisedAJAX("GET", `api/addr/${addr}/balance`).then(balance => {
-          resolve(parseFloat(balance));
-        }).catch(error => {
-          reject(error);
-        });
+        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) => {
-        this.sendTx(senderAddr, receiverAddr, floGlobals.sendAmt, PrivKey, Data).then(txid => {
-          resolve(txid);
-        }).catch(error => {
-          reject(error);
-        });
+        this.sendTx(senderAddr, receiverAddr, floGlobals.sendAmt, PrivKey, Data)
+            .then(txid => resolve(txid))
+            .catch(error => reject(error))
       });
     },
 
@@ -5038,8 +5693,7 @@
           var trx = bitjs.transaction();
           var utxoAmt = 0.0;
           var fee = floGlobals.fee;
-          this.promisedAJAX("GET", `api/addr/${senderAddr}/utxo`).then(response => {
-            var utxos = JSON.parse(response);
+          this.promisedAPI(`api/addr/${senderAddr}/utxo`).then(utxos => {
             for (var i = utxos.length - 1;
               (i >= 0) && (utxoAmt < sendAmt + fee); i--) {
               if (utxos[i].confirmations) {
@@ -5056,15 +5710,11 @@
                 trx.addoutput(senderAddr, change);
               trx.addflodata(floData);
               var signedTxHash = trx.sign(PrivKey, 1);
-              this.broadcastTx(signedTxHash).then(txid => {
-                resolve(txid)
-              }).catch(error => {
-                reject(error);
-              });
+              this.broadcastTx(signedTxHash)
+                .then(txid => resolve(txid))
+                .catch(error => reject(error))
             }
-          }).catch(error => {
-            reject(error);
-          });
+          }).catch(error => reject(error))
         }
       });
     },
@@ -5073,7 +5723,7 @@
     broadcastTx: function (signedTxHash) {
       return new Promise((resolve, reject) => {
         var request = new XMLHttpRequest();
-        var url = `${floGlobals.apiURL[floGlobals.blockchain]}/api/tx/send`;
+        var url = this.util.serverList[this.util.curPos] + 'api/tx/send';
         if (signedTxHash.length < 1)
           reject("Empty Signature");
         else {
@@ -5096,27 +5746,20 @@
     //Read Txs of Address between from and to
     readTxs: function (addr, from, to) {
       return new Promise((resolve, reject) => {
-        this.promisedAJAX("GET", `api/addrs/${addr}/txs?from=${from}&to=${to}`).then(response => {
-          resolve(JSON.parse(response));
-        }).catch(error => {
-          reject(error);
-        });
+        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.promisedAJAX("GET", `api/addrs/${addr}/txs?from=0&to=1`).then(response => {
-          var totalItems = JSON.parse(response).totalItems;
-          this.promisedAJAX("GET", `api/addrs/${addr}/txs?from=0&to=${totalItems}0`).then(response => {
-            resolve(JSON.parse(response).items);
-          }).catch(error => {
-            reject(error);
-          });
-        }).catch(error => {
-          reject(error);
-        });
+        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))
       });
     },
 
@@ -5130,13 +5773,12 @@
     filter      : custom filter funtion for floData (eg . filter: d => {return d[0] == '$'})
     */
     readData: function(addr,options = {}){
-        options.limit = options.limit || 1000
-        options.ignoreOld = options.ignoreOld || 0
+        options.limit = options.limit | 1000
+        options.ignoreOld = options.ignoreOld | 0
         return new Promise((resolve, reject) => {
-        this.promisedAJAX("GET", `api/addrs/${addr}/txs?from=0&to=1`).then(response => {
-          var newItems = JSON.parse(response).totalItems - options.ignoreOld;
-          this.promisedAJAX("GET", `api/addrs/${addr}/txs?from=0&to=${newItems*2}`).then(response => {
-              response = JSON.parse(response)
+        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 = [];
@@ -5216,16 +5858,94 @@
         this.addContact(decodedId, address, KB);
       },
       isNodePresent: function (flo_id, KB = this.supernodeKBucket) {
+        let kArray = KB.toArray();
+        let kArrayFloIds = kArray.map(k => k.floID);
+        if (kArrayFloIds.includes(flo_id))
+            return true;
+        else
+            return false;
+      },
+ 
+      getInnerNodes: function(flo_addr1, flo_addr2, KB = this.supernodeKBucket){
         return new Promise((resolve, reject) => {
-          let kArray = KB.toArray();
-          let kArrayFloIds = kArray.map(k => k.data.id);
-          if (kArrayFloIds.includes(flo_id)) {
-            resolve(true);
-          } else {
-            reject(false);
+          let kArrayFloIds = KB.toArray().map(k => k.floID);
+          var innerNodes = []
+          if(kArrayFloIds.includes(flo_addr1) && kArrayFloIds.includes(flo_addr2)){
+            for(var i = kArrayFloIds.indexOf(flo_addr1); i!= flo_addr2; i++){
+                if(i >= kArrayFloIds.length)
+                    i = -1
+                else
+                    innerNodes.push(kArrayFloIds[i])
+            }
+            resolve(innerNodes)
+          }else
+            reject('Given nodes are not in KBucket')
+        });
+      },
+
+      getOuterNodes: function(flo_addr1, flo_addr2, KB = this.supernodeKBucket){
+        return new Promise((resolve, reject) => {
+          let kArrayFloIds = KB.toArray().map(k => k.floID);
+          var outterNodes = []
+          if(kArrayFloIds.includes(flo_addr1) && kArrayFloIds.includes(flo_addr2)){
+            for(var i = kArrayFloIds.indexOf(flo_addr2); i!= flo_addr1; i++){
+                if(i >= kArrayFloIds.length)
+                    i = -1
+                else
+                    outterNodes.push(kArrayFloIds[i])
+            }
+            resolve(outterNodes)
+          }else
+            reject('Given nodes are not in KBucket')
+        });
+      },
+
+      getPrevSupernode: function(flo_addr, n = 1, KB = this.supernodeKBucket){
+        return new Promise((resolve, reject) => {
+          try {
+            let isFloIdUint8 = flo_addr instanceof Uint8Array;
+            if (!isFloIdUint8)
+              flo_addr = this.floIdToKbucketId(flo_addr);
+            const KA = KB.toArray();
+            let pos = KB._indexOf(KB.root,flo_addr)
+            var prevSupernode = []
+            for(var i = 1; i <= n; i++){
+                if(pos - i < 0)
+                    var prev = pos - i + KA.length
+                else
+                    var prev = pos - i
+                prevSupernode.push(KA[prev])
+            }
+            resolve(prevSupernode);
+          } catch (error) {
+            reject(error);
           }
         });
       },
+
+      getNextSupernode: function(flo_addr, n = 1, KB = this.supernodeKBucket){
+        return new Promise((resolve, reject) => {
+          try {
+            let isFloIdUint8 = flo_addr instanceof Uint8Array;
+            if (!isFloIdUint8)
+              flo_addr = this.floIdToKbucketId(flo_addr);
+            const KA = KB.toArray();
+            let pos = KB._indexOf(KB.root,flo_addr)
+            var nextSupernode = []
+            for(var i = 1; i <= n; i++){
+                if(pos + i >= KA.length)
+                    var next = pos + i - KA.length
+                else
+                    var next = pos + i
+                nextSupernode.push(KA[next])
+            }
+            resolve(nextSupernode);
+          } catch (error) {
+            reject(error);
+          }
+        });
+      },
+
       determineClosestSupernode: function (flo_addr, n = 1, KB = this.supernodeKBucket) {
         return new Promise((resolve, reject) => {
           try {
@@ -5354,16 +6074,20 @@
             request = request.split(" ");
             requestor = request[0];
             request = JSON.parse(request[1]);
-            var filterOptions = {
-                lowerKey: request.lowerVectorClock,
-                upperKey: request.upperVectorClock,
-                lastOnly: request.mostRecent,
-                atKey: request.atVectorClock,
-                patternEval: (k, v) => { return (v.application == request.application && (!request.receiverID || v.receiverID == request.receiverID) && (!request.comment || v.comment == request.comment) && (!request.type || v.type == request.type) && (!request.senderIDs || request.senderIDs.includes(v.senderID))) }
-            }
-            compactIDB.searchData( floGlobals.storageList.includes(request.application) ? request.application : floGlobals.defaultStorage, filterOptions)
-                .then(result => floSupernode.supernodeClientWS.send(`${requestor} ${JSON.stringify(result)}`))
-                .catch(error => console.log(error))
+            floSupernode.kBucket.determineClosestSupernode(request.receiverID).then(result => {
+                if(floGlobals.serveList.includes(result[0].floID)){
+                    var filterOptions = {
+                        lowerKey: request.lowerVectorClock,
+                        upperKey: request.upperVectorClock,
+                        lastOnly: request.mostRecent,
+                        atKey: request.atVectorClock,
+                        patternEval: (k, v) => { return (v.application == request.application && v.receiverID == request.receiverID && (!request.comment || v.comment == request.comment) && (!request.type || v.type == request.type) && (!request.senderIDs || request.senderIDs.includes(v.senderID))) }
+                    }
+                    compactIDB.searchData( floGlobals.diskList.includes(request.application) ? request.application : floGlobals.defaultDisk, filterOptions, `SN_${result[0].floID}`)
+                        .then(result => floSupernode.supernodeClientWS.send(`${requestor} ${JSON.stringify(result)}`))
+                        .catch(error => console.log(error))
+                }
+            }).catch(error => console.log(error))
         } catch (error) {
             console.log(error.message)
         }
@@ -5375,27 +6099,28 @@
         console.log('Data :', data);
         try {
             data = JSON.parse(data)
-            floSupernode.kBucket.determineClosestSupernode(data.receiverID).then(result => {
-                if (result[0].floID != myFloID)
-                    return;
-                if (data.senderID == floCrypto.getFloIDfromPubkeyHex(data.pubKey) && floCrypto.verifySign(
-                        JSON.stringify(data.message), data.sign, data.pubKey)) {
-                    if (floGlobals.storageList.includes(data.application))
-                        var table = data.application;
-                    else
-                        var table = floGlobals.defaultStorage;
-                    compactIDB.addData(table, {
-                        senderID: data.senderID,
-                        receiverID: data.receiverID,
-                        pubKey: data.pubKey,
-                        message: data.message,
-                        sign: data.sign,
-                        application: data.application,
-                        type: data.type,
-                        comment: data.comment
-                    })
-                }
-            })
+            if(!data.backupMsg){   //Serving Users
+                floSupernode.kBucket.determineClosestSupernode(data.receiverID).then(result => {
+                    if (floGlobals.serveList.includes(result[0].floID)         
+                    && data.senderID == floCrypto.getFloIDfromPubkeyHex(data.pubKey) 
+                    && floCrypto.verifySign(JSON.stringify(data.message), data.sign, data.pubKey)){
+                        var key = `${Date.now()}_${data.senderID}`
+                        var value = {
+                            senderID: data.senderID,
+                            receiverID: data.receiverID,
+                            pubKey: data.pubKey,
+                            message: data.message,
+                            sign: data.sign,
+                            application: data.application,
+                            type: data.type,
+                            comment: data.comment
+                        }
+                        compactIDB.addData(floGlobals.diskList.includes(value.application) ? value.application:floGlobals.defaultDisk , value ,key,`SN_${result[0].floID}`)
+                        reactor.dispatchEvent("send_backup",{ key:key, value:value, snfloID: result[0].floID})
+                    }
+                }).catch(error => console.log(error))
+            }else if(data.from in floGlobals.supernodes)
+                reactor.dispatchEvent("backup_message_event", data)
         } catch (error) {
             console.log(error.message);
         }
@@ -5419,7 +6144,7 @@
 
     initDB: function (dbName, objectStores = {}) {
       return new Promise((resolve, reject) => {
-        this.dbName = this.dbName || dbName;
+        //this.dbName = this.dbName || dbName;
         var idb = indexedDB.open(dbName);
         idb.onerror = (event) => {
           reject("Error in opening IndexedDB!");
@@ -5535,7 +6260,7 @@
     },
 
     searchData: function (obsName, options = {}, dbName = this.dbName) {
-        options.lowerKey = options.atKey || options.lowerKey || 1
+        options.lowerKey = options.atKey || options.lowerKey || 0
         options.upperKey = options.atKey || options.upperKey || false
         options.patternEval = options.patternEval || ((k,v) => {return true})
         options.lastOnly = options.lastOnly || false
@@ -5970,64 +6695,250 @@
 </script>
 
 <script id="SuperNodeStorageScript">
-    function onLoadStartUp() {
-        myPrivKey = prompt("Enter Private Key : ")
-        myPubKey = floCrypto.getPubKeyHex(myPrivKey)
-        myFloID = floCrypto.getFloIDfromPubkeyHex(myPubKey)
 
-        initIndexedDBforSupernode().then(result => {
-            console.log(result)
-            readSupernodeListFromAPI().then(result => {
-                console.log(result)
-                floSupernode.kBucket.launch().then(result => {
-                    console.log(result)
-                    if (myFloID in floGlobals.supernodes) {
-                        serverPwd = prompt("Enter Server Pass!")
-                        setInterval(refreshBlockchainData, 3600000);
-                        floSupernode.initSupernode(serverPwd, myFloID)
-                            .then(result => console.log(result))
-                            .catch(error => console.log(error))
-                    }
-                })
-            })
-        }).catch(error => console.log(error))
+    function sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
     }
 
-    function initIndexedDBforSupernode(){
+    function onLoadStartUp() {
+
+        initIndexedDBforSupernodeConfig().then(result => {
+            console.log(result)
+            refreshBlockchainData().then(result => {
+                console.log(result)
+                getCredentials().then(result => {
+                    if (myFloID in floGlobals.supernodes) {
+                        initIndexedDBforSupernodeDataStorage(myFloID).then(result => {
+                            console.log(result)
+                            setInterval(autoRefreshBlockchainData, floGlobals.refreshDelay);
+                            floSupernode.initSupernode(serverPwd, myFloID).then(async result => {
+                                console.log(result)
+                                floGlobals.serveList.push(myFloID)
+                                floGlobals.storedList.push(myFloID)
+                                await sleep(5000)
+                                connectToAllBackupSupernode().then(async result => {
+                                    console.log(result)
+                                    await sleep(2000)
+                                    reactor.dispatchEvent("indicate_supernode_up",myFloID)
+                                }).catch(error => console.log(error))
+                            }).catch(error => console.log(error))
+                        }).catch(error => console.log(error))
+                    }
+                }).catch(error => console.log(error))
+            }).catch(error => console.log(error))
+        }).catch(error => console.log(error))
+    }
+      
+    function getCredentials(){
         return new Promise((resolve, reject) => {
-            var IndexesList = ["senderID","receiverID","pubKey","message","sign","application","type","comment"];
-            var primaryKey = "vectorClock";
-            var storageList = floGlobals.storageList;
-            var obj = {
+            getPrivateKeyCredentials().then(privKey => {
+                myPrivKey = privKey
+                myPubKey = floCrypto.getPubKeyHex(myPrivKey)
+                myFloID = floCrypto.getFloIDfromPubkeyHex(myPubKey)
+                getServerPasswordCredentials().then(pass => {
+                    serverPwd = pass
+                    resolve('Login Credentials loaded successful')
+                }).catch(error => reject(error))
+            }).catch(error => reject(error))
+        })
+    }
+
+    function getPrivateKeyCredentials(){
+        return new Promise((resolve, reject) => {
+            var indexArr = localStorage.getItem("privKey")
+            if(indexArr){
+                readSharesFromIDB(JSON.parse(indexArr))
+                    .then(result => resolve(result))
+                    .catch(error => reject(error))
+            }else{
+                try{
+                    var privKey = prompt("Enter Private Key: ")
+                    if(!privKey)
+                        return reject("Empty Private Key")
+                    var floID = floCrypto.getFloIDfromPubkeyHex(floCrypto.getPubKeyHex(privKey))
+                    console.log(floID)
+                    alert(`Supernode floID: ${floID}`)
+                }catch(error){
+                    console.log(error)
+                    return reject("Invalid Private Key")
+                }
+                var threshold = floCrypto.randInt(10,20)
+                writeSharesToIDB(floCrypto.createShamirsSecretShares(privKey, threshold, threshold)).then(resultIndexes =>{
+                    //store index keys in localStorage
+                    localStorage.setItem("privKey", JSON.stringify(resultIndexes))
+                    //also add a dummy privatekey to the IDB
+                    var randomPrivKey = floCrypto.generateNewID().privKey
+                    var randomThreshold = floCrypto.randInt(10,20)
+                    writeSharesToIDB(floCrypto.createShamirsSecretShares(randomPrivKey, randomThreshold, randomThreshold))
+                    //resolve private Key
+                    resolve(privKey)
+                }).catch(error => reject(error))
+            }
+        })
+    }
+
+    function getServerPasswordCredentials(){
+        return new Promise((resolve, reject) => {
+            var indexArr = localStorage.getItem("serverPass")
+            if(indexArr){
+                readSharesFromIDB(JSON.parse(indexArr))
+                    .then(result => resolve(result))
+                    .catch(error => reject(error))
+            }else{
+                var serverPass = prompt("Enter Server Password: ")
+                if(!serverPass)
+                    return reject("Empty Server Password")
+                var threshold = floCrypto.randInt(10,20)
+                writeSharesToIDB(floCrypto.createShamirsSecretShares(serverPass, threshold, threshold)).then(resultIndexes =>{
+                    //store index keys in localStorage
+                    localStorage.setItem("serverPass", JSON.stringify(resultIndexes))
+                    //also add a dummy string to the IDB
+                    var randomLength = floCrypto.randInt(serverPass.length - 5, serverPass.length + 5)
+                    var randomString = floCrypto.randString(randomLength)
+                    var randomThreshold = floCrypto.randInt(10,20)
+                    writeSharesToIDB(floCrypto.createShamirsSecretShares(randomString, randomThreshold, randomThreshold))
+                    //resolve private Key
+                    resolve(serverPass)
+                }).catch(error => reject(error))
+            }
+        })
+    }
+
+    function readSharesFromIDB(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))
+        })
+    }
+
+    function writeSharesToIDB(shares, i = 0, resultIndexes = []){
+        return new Promise((resolve, reject) => {
+            if(i >= shares.length)
+                return resolve(resultIndexes)
+            var n = floCrypto.randInt(0, 100000)
+            compactIDB.addData("credentials", shares[i], n).then(res => {
+                resultIndexes.push(n)
+                writeSharesToIDB(shares, i+1, resultIndexes)
+                    .then(result => resolve(result))
+            }).catch(error => {
+                writeSharesToIDB(shares, i, resultIndexes)
+                    .then(result => resolve(result))
+            })
+        }) 
+    }
+
+    function clearCredentials(type = 'Both'){
+        if(type === 'Both')
+            return clearCredentials('privKey') + clearCredentials('serverPass')
+        else if(type === 'privKey' || type === 'serverPass'){
+            var indexArr = localStorage.getItem(type)
+            if(!indexArr)
+                return `${type} credentials not found!\n`
+            indexArr = JSON.parse(indexArr)
+            indexArr.forEach(i => compactIDB.removeData('credentials', i))
+            localStorage.removeItem(type)
+            return `${type} credentials deleted!\n`
+        }
+    }
+
+    function initIndexedDBforSupernodeConfig(){
+        return new Promise((resolve, reject) => {
+            var diskList = floGlobals.diskList;
+            var snObj = {
                 lastTx:{},
+                config:{},
+                credentials:{},
                 supernodes:{
                     indexes:{ uri:null, pubKey:null }
+                },
+                applications:{},
+                appSubAdmins:{
+                    indexes:{ app:null, subAdminID:null }
                 }
             }
-            for(var i=0;i<storageList.length;i++){
-                obj[storageList[i]] = {
-                    options:{keyPath:primaryKey,autoIncrement:true},
-                    indexes:{}
-                }
-                for(var j=0;j<IndexesList.length;j++)
-                    obj[storageList[i]].indexes[IndexesList[j]] = null;
-            }
-            compactIDB.initDB("SupernodeStorage",obj)
-                .then(result => resolve("Initiated supernode storage"))
+            compactIDB.setDefaultDB("SupernodeUtil")
+            compactIDB.initDB("SupernodeUtil", snObj)
+                .then(result => resolve("Initiated supernode configuration IDB"))
                 .catch(error => reject(error));
         })
     }
 
-    function refreshBlockchainData(){
-        readSupernodeListFromAPI().then(result => {
+    function initIndexedDBforSupernodeDataStorage(floID){
+        return new Promise((resolve, reject) => {
+            var indexesList = ["senderID","receiverID","pubKey","message","sign","application","type","comment"];
+            var diskList = floGlobals.diskList
+            var idbObj = {}
+            for(var i=0;i<diskList.length;i++){
+                idbObj[diskList[i]] = {
+                    indexes:{}
+                }
+                for(var j=0;j<indexesList.length;j++)
+                    idbObj[diskList[i]].indexes[indexesList[j]] = null;
+            }
+            compactIDB.initDB(`SN_${floID}`, idbObj)
+                .then(result => resolve("Initiated supernode storage IDB for "+floID))
+                .catch(error => reject(error));
+        })
+    }
+
+    function autoRefreshBlockchainData(){
+        refreshBlockchainData().then(result => {
             console.log(result)
-            floSupernode.kBucket.launch().then(result => {
-                console.log(result)
-            })
+            autoDeleteStoredData()
+                .then(result => console.log(result))
+                .catch(error => console.log(error))
         }).catch(error => console.log(error))
     }
 
-    function readSupernodeListFromAPI(){
+    function autoDeleteStoredData(){
+        return new Promise((resolve, reject) => {
+            var deleteEnd = Date.now() - floGlobals.supernodeConfig.deleteDelay
+            var deleteStart = deleteEnd - floGlobals.refreshDelay
+            var promises = []
+            var filterOptions = {
+                lowerKey: `${deleteStart}`,
+                upperKey: `${deleteEnd}`,
+            }
+            for(var i = 0; i < floGlobals.storedList.length; i++){
+                var promise = new Promise((res,rej) => {
+                    compactIDB.searchData(floGlobals.defaultDisk,filterOptions,`SN_${floGlobals.storedList[i]}`).then(results => {
+                        for(key in results)
+                            if(!floGlobals.applicationList.includes(results[key].application) || !floGlobals.appSubAdmins[results[key].application].includes(results[key].senderID))
+                                compactIDB.removeData(floGlobals.defaultDisk, key, `SN_${floGlobals.storedList[i]}`)
+                        res(`Auto-delete successful for SN_${floGlobals.storedList[i]} from ${deleteStart} to ${deleteEnd}`)
+                    }).catch(error => rej(error))
+                })
+                promises.push(promise)
+            }
+            Promise.all(promises).then(results => {
+                resolve(`Auto-delete successful from ${deleteStart} to ${deleteEnd}`)
+            }).catch(error => reject(error))
+        })
+    }
+
+    function refreshBlockchainData(){
+        return new Promise((resolve,reject) => {
+            readSupernodeDataFromAPI().then(result => {
+                console.log(result)
+                readAppSubAdminListFromAPI().then(result => {
+                    floSupernode.kBucket.launch().then(result => {
+                        console.log(result)
+                        resolve("Refreshed Data from blockchain")
+                    }).catch(error => reject(error))
+                }).catch(error => reject(error))
+            }).catch(error => reject(error))
+        })
+    }
+
+    function readSupernodeDataFromAPI(){
         return new Promise((resolve,reject) => {
             compactIDB.readData("lastTx",floGlobals.adminID).then(lastTx => {
                 floBlockchainAPI.readData(floGlobals.adminID,{ignoreOld:lastTx,sendOnly:true,pattern:"SuperNodeStorage"}).then(result => {
@@ -6037,17 +6948,537 @@
                             compactIDB.removeData("supernodes",sn);
                         for(sn in content.addNodes)
                             compactIDB.writeData("supernodes",content.addNodes[sn],sn);
+                        for(c in content.config)
+                            compactIDB.writeData("config",content.config[c],c)
+                        for(app in content.application)
+                            compactIDB.writeData("applications",content.application[app],app)
                     }
                     compactIDB.writeData("lastTx",result.totalTxs,floGlobals.adminID);
-                    compactIDB.readAllData("supernodes").then(result => {
-                        floGlobals.supernodes = result
-                        resolve("Read supernode from blockchain");                    
-                    })
-                })
+                    compactIDB.readAllData("supernodes").then(supernodes => {
+                        floGlobals.supernodes = supernodes
+                        compactIDB.readAllData("config").then(config => {
+                            floGlobals.supernodeConfig = config
+                            compactIDB.readAllData("applications").then(applications => {
+                                floGlobals.applicationList = applications
+                                resolve("Read Supernode Data from Blockchain");       
+                            }).catch(error => reject(error))             
+                        }).catch(error => reject(error))                   
+                    }).catch(error => reject(error))
+                }).catch(error => reject(error))
             }).catch(error => reject(error))
         })
     }
+
+    function readAppSubAdminListFromAPI(){
+        return new Promise((resolve,reject) => {
+            var promises = []
+            for(app in floGlobals.applicationList){
+                var promise = new Promise((res,rej) => {
+                    compactIDB.readData("appSubAdmins", app).then(subAdmins => {
+                        compactIDB.readData("lastTx",floGlobals.applicationList[app]).then(lastTx => {
+                            floBlockchainAPI.readData(floGlobals.applicationList[app],{ignoreOld:lastTx,sentOnly:true,pattern:app}).then(result => {
+                                for(var i = result.data.length-1; i>=0; i--){
+                                    var content = JSON.parse(result.data[i])[app];
+                                    if(Array.isArray(content.removeSubAdmin))
+                                        subAdmins = subAdmins.filter(x => !content.removeSubAdmin.includes(x));
+                                    if(Array.isArray(content.addSubAdmin))
+                                        subAdmins = subAdmins.concat(content.addSubAdmin)
+                                }            
+                                compactIDB.writeData("lastTx", result.totalTxs, floGlobals.adminID);
+                                compactIDB.writeData("appSubAdmins", subAdmins, app)
+                                    .then(result => res(app))
+                                    .catch(error => rej(error))
+                            }).catch(error => rej(error))
+                        }).catch(error => rej(error))
+                    }).catch(error => rej(error))
+                })
+                promises.push(promise)
+            }
+            Promise.all(promises).then(results => {
+                compactIDB.readAllData("appSubAdmins").then(result => {
+                    floGlobals.appSubAdmins = result
+                    resolve("Read all subAdmin list from blockchain")
+                }).catch(error => reject(error))
+            }).catch(error => reject(error))
+        })
+    }
+
+    function connectToAllBackupSupernode(curNode = myFloID, i = 0){
+        return new Promise((resolve,reject) => {
+            if(i >= floGlobals.supernodeConfig.backupDepth)
+                resolve("Connected to all backup nodes")
+            else{
+                floSupernode.kBucket.getNextSupernode(curNode).then(nextBackupNode => {
+                    if(myFloID === nextBackupNode[0].floID)
+                        reject("Not enough supernodes available")
+                    else{
+                        connectToBackupSupernode(nextBackupNode[0].floID).then(backupConn => {
+                            floGlobals.backupNodes[i] = backupConn
+                            connectToAllBackupSupernode(backupConn.floID, i+1)
+                                .then(result => resolve(result))
+                                .catch(error => reject(error))
+                        }).catch(error => reject(error))
+                    }
+                }).catch(error => reject(error))    
+            }
+        })
+    }
+
+    function connectToBackupSupernode(backupNodeID){
+        return new Promise((resolve,reject) => {
+            initateBackupWebsocket(backupNodeID)
+                .then(result => resolve(result))
+                .catch(error => {
+                    console.log(error)
+                    floSupernode.kBucket.getNextSupernode(backupNodeID).then(nextBackupNode => {
+                        connectToBackupSupernode(nextBackupNode[0].floID).then(result => resolve(result))
+                    }).catch(error => console.log(error))    
+                })
+        })
+    }
+
+    function initateBackupWebsocket(backupNodeID){
+        return new Promise((resolve,reject) => {
+            try{
+                console.log(backupNodeID)
+                var backupNode = {
+                    floID: backupNodeID,
+                    wsConn: new WebSocket("wss://" + floGlobals.supernodes[backupNodeID].uri + "/ws")
+                }
+                backupNode.wsConn.onopen = (evt) => {
+                    backupNode.wsConn.onmessage = (ev) => reactor.dispatchEvent("backup_node_message",{floID:backupNodeID,data:ev.data});     
+                    backupNode.wsConn.onclose = (ev) => reactor.dispatchEvent("backup_node_disconnected",backupNodeID);
+                    resolve(backupNode);
+                }
+                backupNode.wsConn.onerror = (evt) => reject(`${backupNodeID} ws not found`);
+            }catch(error){
+                reject(error.message)
+            }
+        })
+    }
 </script>
 
+<script>
+    /*Reactor Events for supernode backup feature*/
+
+    reactor.registerEvent("backup_node_message");
+    reactor.addEventListener("backup_node_message", function (event) {
+        console.log("backup_node_message");
+        //received message from backup node
+        if(event.data == "$+")
+            reactor.dispatchEvent("backup_node_online", event.floID);
+        else if (event.data == "$-")
+            reactor.dispatchEvent("backup_node_offline", event.floID);
+        else
+            console.log(event.data)
+    })
+
+    reactor.registerEvent("backup_node_disconnected");
+    reactor.addEventListener("backup_node_disconnected", function (backupNodeID) {
+        console.log("backup_node_disconnected");
+        //try to reconnect (usually disconnects due to timeout) 
+        initateBackupWebsocket(backupNodeID)
+            .then(result => console.log(result))
+            .catch(error =>{ 
+                console.log(error)
+                reactor.dispatchEvent("backup_node_offline",backupNodeID);
+            })
+    })
+
+    reactor.registerEvent("backup_node_online");
+    reactor.addEventListener("backup_node_online", function (backupNodeID) {
+        console.log("backup_node_online");
+        //backup node is alive. 
+        //do nothing for now
+    })
+
+    reactor.registerEvent("backup_node_offline");
+    reactor.addEventListener("backup_node_offline", function (offlineNodeID) {
+        console.log("backup_node_offline");
+        //remove offline node and add the immediate next available node
+        var index = floGlobals.backupNodes.indexOf(offlineNodeID);
+        if (index !== -1) floGlobals.backupNodes.splice(index, 1);
+        //connect to next node available
+        var len = floGlobals.backupNodes.length
+        connectToAllBackupSupernode(len == 0? offlineNodeID : floGlobals.backupNodes[len-1], len).then(result => {
+            console.log(result)
+            //inform the newly connected node to store backups of all serving
+            for(var i = 0; i < floGlobals.serveList.length; i++){
+                var sendData1 = {
+                    from: myFloID,
+                    backupMsg: {
+                        type: "startBackupStore",
+                        snfloID: myFloID,
+                        time: Date.now()
+                    }
+                }
+                sendData1.sign = floCrypto.signData(JSON.stringify(sendData1.backupMsg), myPrivKey)
+                floGlobals.backupNodes[len].wsConn.send(JSON.stringify(sendData1))
+            }
+            //inform the immediate next node of the dead to start serving it
+            if(index == 0){
+                var sendData2 = {
+                    from: myFloID,
+                    backupMsg: {
+                        type: "startBackupServe",
+                        snfloID: offlineNodeID,
+                        time: Date.now()
+                    }
+                }
+                sendData2.sign = floCrypto.signData(JSON.stringify(sendData2.backupMsg), myPrivKey)
+                floGlobals.backupNodes[0].wsConn.send(JSON.stringify(sendData2))
+            }
+        }).catch(error => {
+            console.log(error)
+            if(index == 0){
+                //start serving the dead node
+                if(floGlobals.backupNodes.length === 0)
+                    floGlobals.serveList.push(offlineNodeID)
+                //inform the immediate next node of the dead to start serving it
+                else{
+                    var sendData2 = {
+                        from: myFloID,
+                        backupMsg: {
+                            type: "startBackupServe",
+                            snfloID: offlineNodeID,
+                            time: Date.now()
+                        }
+                    }
+                    sendData2.sign = floCrypto.signData(JSON.stringify(sendData2.backupMsg), myPrivKey)
+                    floGlobals.backupNodes[0].wsConn.send(JSON.stringify(sendData2))
+                }
+            }
+        })
+    })
+
+    reactor.registerEvent("send_message_to_backup_nodes");
+    reactor.addEventListener("send_message_to_backup_nodes", function (backupMsg) {
+        console.log("send_message_to_backup_nodes");
+        //send message to all connected backup nodes
+        var sendData = {
+            from: myFloID,
+            backupMsg: backupMsg,
+            sign: floCrypto.signData(JSON.stringify(backupMsg), myPrivKey)
+        }
+        for(var i = 0; i < floGlobals.backupNodes.length; i++)
+            floGlobals.backupNodes[i].wsConn.send(JSON.stringify(sendData))
+    })
+
+    reactor.registerEvent("send_message_to_node");
+    reactor.addEventListener("send_message_to_node", function (event) {
+        console.log("send_message_to_node");
+        //send message to a supernode
+        try{
+            var nodeWS =  new WebSocket("wss://" + floGlobals.supernodes[event.snfloID].uri + "/ws")
+            nodeWS.onopen = (evt) => {
+                if(event.backupMsg){
+                    var sendData = {
+                        from: myFloID,
+                        backupMsg: event.backupMsg,
+                        sign: floCrypto.signData(JSON.stringify(event.backupMsg), myPrivKey)
+                    }
+                    nodeWS.send(JSON.stringify(sendData))
+                }
+                if(event.bulkBackupMsg){
+                    for(var i=0; i < event.bulkBackupMsg.length; i++){
+                        var sendData = {
+                            from: myFloID,
+                            backupMsg: event.bulkBackupMsg[i],
+                            sign: floCrypto.signData(JSON.stringify(event.bulkBackupMsg[i]), myPrivKey)
+                        }
+                        nodeWS.send(JSON.stringify(sendData))
+                    }
+                }
+                
+            }
+            nodeWS.onmessage = (evt) => console.log(evt.data);     
+            nodeWS.onclose = (evt) => console.log("Disconnected from " + event.holder);
+            nodeWS.onerror = (evt) => console.log("Error connecting to " + event.holder);
+        }catch(error){
+            console.log(error.message)
+        }
+    })
+
+    reactor.registerEvent("send_backup");
+    reactor.addEventListener("send_backup", function (data) {
+        console.log("send_backup");
+        //send backup data to backup nodes
+        var backupMsg = {
+            type: "backupData",
+            snfloID: data.snfloID,
+            key: data.k,
+            value: data.value
+        }
+        reactor.dispatchEvent("send_message_to_backup_nodes", backupMsg)
+    })
+
+    reactor.registerEvent("send_stored_backup");
+    reactor.addEventListener("send_stored_backup", function (event) {
+        console.log("send_stored_backup");
+        //send stored backuped data to the requestor node
+        if(floGlobals.storedList.includes(event.snfloID)){
+            try{
+                var requestorWS =  new WebSocket("wss://" + floGlobals.supernodes[event.from].uri + "/ws")
+                requestorWS.onopen = (evt) => {
+                    floGlobals.diskList.forEach(obs => {
+                        compactIDB.searchData(obs, {lowerKey: event.lowerKey[obs]}, `SN_${event.snfloID}`).then(result => {
+                            for(k in result){
+                                var sendData = {
+                                    from: myFloID,
+                                    backupMsg: {
+                                        type: "backupData",
+                                        snfloID: event.snfloID,
+                                        key: k,
+                                        value: result[k]
+                                    }
+                                }
+                                sendData.sign = floCrypto.signData(JSON.stringify(sendData.backupMsg), myPrivKey)
+                                requestorWS.send(JSON.stringify(sendData))
+                            }
+                        }).catch(error => console.log(error))
+                    })
+                }
+                requestorWS.onmessage = (evt) => console.log(evt.data);     
+                requestorWS.onclose = (evt) => console.log("Disconnected from " + event.from);
+                requestorWS.onerror = (evt) => console.log("Error connecting to " + event.from);
+            }catch(error){
+                console.log(error.message)
+            }
+        }
+    })
+
+    reactor.registerEvent("backup_message_event");
+    reactor.addEventListener("backup_message_event", function (data) {
+        console.log("backup_message_event");
+        if(floCrypto.verifySign(JSON.stringify(data.backupMsg), data.sign, floGlobals.supernodes[data.from].pubKey)){
+            //Backup event messages (most crucial part)
+            
+            switch(data.backupMsg.type){
+                case "backupData":
+                    reactor.dispatchEvent("store_backup_data", data.backupMsg)
+                    break;
+                case "supernodeUp":
+                    reactor.dispatchEvent("supernode_back_online", data.backupMsg.snfloID)
+                    break;
+                case "startBackupServe":
+                    reactor.dispatchEvent("start_backup_serve", data.backupMsg.snfloID)
+                    break;
+                case "stopBackupServe":
+                    reactor.dispatchEvent("stop_backup_serve", data.backupMsg.snfloID)
+                    break;
+                case "startBackupStore":
+                    reactor.dispatchEvent("start_backup_store", {from:data.from, snfloID:data.backupMsg.snfloID})
+                    break;
+                case "stopBackupStore":
+                    reactor.dispatchEvent("stop_backup_store", data.backupMsg.snfloID)
+                    break;
+                case "dataRequest":
+                    reactor.dispatchEvent("send_stored_backup", {from:data.from, snfloID:data.backupMsg.snfloID, lowerKey:data.backupMsg.lowerKey})
+                    break;
+                default:
+                    console.log(data.backupMsg)
+            }
+        }
+    })
+
+    reactor.registerEvent("request_data");
+    reactor.addEventListener("request_data", function (event) {
+        console.log("request_data");
+        //request the backup data
+        var promises = []
+        for(var i=0; i < floGlobals.diskList.length; i++)
+            promises[i] = compactIDB.searchData(floGlobals.diskList[i], {lastOnly: true},`SN_${event.snfloID}`)
+        Promise.all(promises).then(results => {
+            var lowerKey = {}
+            for(var i=0; i < results.length; i++)
+                for(key in results[i])
+                    lowerKey[floGlobals.diskList[i]] = key
+            var backupMsg = {
+                type: "dataRequest",
+                snfloID: event.snfloID,
+                lowerKey: lowerKey,
+                time: Date.now()
+            }
+            reactor.dispatchEvent("send_message_to_node", {snfloID:event.holder, backupMsg:backupMsg})
+        })
+    })
+
+    reactor.registerEvent("store_backup_data");
+    reactor.addEventListener("store_backup_data", function (data) {
+        console.log("store_backup_data");
+        //store received backup data
+        if(floGlobals.storedList.includes(data.backupMsg.snfloID)){
+            compactIDB.addData(
+                floGlobals.diskList.includes(data.value.application) ? data.value.application:floGlobals.defaultDisk, 
+                data.value, data.key, `SN_${data.snfloID}`
+            )
+        }
+    })
+    
+    reactor.registerEvent("indicate_supernode_up");
+    reactor.addEventListener("indicate_supernode_up", function (snfloID) {
+        console.log("indicate_supernode_up");
+        //send message to backup's backup to server for backup node
+        var backupMsg1 = {
+            type: "supernodeUp",
+            snfloID: snfloID,
+            time: Date.now()
+        }
+        reactor.dispatchEvent("send_message_to_backup_nodes", backupMsg1)
+        var backupMsg2 = {
+            type: "startBackupStore",
+            snfloID: snfloID,
+            time: Date.now()
+        }
+        reactor.dispatchEvent("send_message_to_backup_nodes", backupMsg2)
+        reactor.dispatchEvent("request_data", {holder:floGlobals.backupNodes[0].floID, snfloID:snfloID})
+    })
+
+    reactor.registerEvent("supernode_back_online");
+    reactor.addEventListener("supernode_back_online", function (snfloID) {
+        console.log("supernode_back_online");
+        if(floGlobals.serveList.includes(snfloID)){
+            //stop serving the revived node
+            reactor.dispatchEvent("stop_backup_serve", snfloID)
+            //inform the revived node to serve the other applicable dead nodes
+            floSupernode.kBucket.getInnerNodes(snfloID, myFloID).then(innerNodes => {
+                for(var i=0; i < floGlobals.serveList.length; i++)
+                    if(!innerNodes.includes(floGlobals.serveList[i])){
+                        var backupMsg = {
+                            type: "startBackupServe",
+                            snfloID: floGlobals.serveList[i],
+                            time: Date.now()
+                        }
+                        reactor.dispatchEvent("send_message_to_node", {snfloID:snfloID, backupMsg:backupMsg}) 
+                        reactor.dispatchEvent("stop_backup_serve", floGlobals.serveList[i])
+                        i--;    //reduce iterator as an element is removed
+                    }
+            })
+        }
+        if(floGlobals.storedList.includes(snfloID)){
+            if(floGlobals.backupNodes.length < floGlobals.supernodeConfig.backupDepth){
+                //when less supernodes available, just connect to the revived node
+                var index = floGlobals.backupNodes.length
+                let kArrayFloIds = this.getNextSupernode(myFloID, KB.toArray().length).map(k => k.floID)
+                for(var i = 0; i < floGlobals.backupNodes.length; i++){
+                    if(snfloID == floGlobals.backupNodes[i].floID){ //revived node is already connected
+                        index = false
+                        break;
+                    }
+                    else if(kArrayFloIds.indexOf(snfloID) < kArrayFloIds.indexOf(floGlobals.backupNodes[i].floID)){
+                        index = i;
+                        break;
+                    }
+                }
+                if(index !== false){
+                    initateBackupWebsocket(snfloID).then(result => {
+                        floGlobals.backupNodes.splice(index, 0, result) // add revived node as backup node
+                    }).catch(error => console.log(error))
+                }
+            }else{
+                var lastBackup = floGlobals.storedList.pop()
+                //inform the revived node to store the backup
+                var backupMsg1 = {
+                    type: "startBackupStore",
+                    snfloID:lastBackup,
+                    time: Date.now()
+                }
+                reactor.dispatchEvent("send_message_to_node", {snfloID:snfloID, backupMsg:backupMsg1})
+                //inform the backup node that a node is revived
+                var backupMsg2 = {
+                    type: "supernodeUp",
+                    snfloID:snfloID,
+                    time: Date.now()
+                }
+                reactor.dispatchEvent("send_message_to_node", {snfloID:lastBackup, backupMsg:backupMsg2})
+            }
+        } else {
+            //connect to the revived node as backup if needed            
+            var index = false
+            let kArrayFloIds = this.getNextSupernode(myFloID, KB.toArray().length).map(k => k.floID)
+            for(var i = 0; i < floGlobals.backupNodes.length; i++){
+                if(snfloID == floGlobals.backupNodes[i].floID) //revived node is already connected
+                    break;
+                else if(kArrayFloIds.indexOf(snfloID) < kArrayFloIds.indexOf(floGlobals.backupNodes[i].floID)){
+                    index = i;
+                    break;
+                }
+            }
+            if(index !== false){
+                initateBackupWebsocket(snfloID).then(result => {
+                    floGlobals.backupNodes.splice(index, 0, result) // add revived node as backup node
+                    floGlobals.backupNodes.pop()    // remove the last extra backup node 
+                }).catch(error => console.log(error))
+            }
+        }
+    })
+
+    reactor.registerEvent("start_backup_serve");
+    reactor.addEventListener("start_backup_serve", function (snfloID) {
+        console.log("start_backup_serve :"+snfloID);
+        //start serving the dead node
+        if(!floGlobals.serveList.includes(snfloID)){
+            floGlobals.serveList.push(snfloID)
+            //indicate the last backup node to store the dead's backup too
+            var sendData = {
+                from: myFloID,
+                backupMsg: {
+                    type: "startBackupStore",
+                    snfloID: snfloID,
+                    time: Date.now()
+                }
+            }
+            sendData.sign = floCrypto.signData(JSON.stringify(sendData.backupMsg), myPrivKey)
+            var lastIndex = floGlobals.backupNodes.length - 1
+            floGlobals.backupNodes[lastIndex].wsConn.send(JSON.stringify(sendData))
+        }
+    })
+
+    reactor.registerEvent("stop_backup_serve");
+    reactor.addEventListener("stop_backup_serve", function (snfloID) {
+        console.log("stop_backup_serve :"+snfloID);
+        //stop serving the revived node
+        var index = floGlobals.serveList.indexOf(snfloID);
+        if (index !== -1 && snfloID !== myFloID) {
+            floGlobals.serveList.splice(index, 1);
+            //indicate the last backup node to stop storing the revived's backup
+            var lastIndex = floGlobals.backupNodes.length - 1
+            if(lastIndex !== -1){
+                var sendData = {
+                    from: myFloID,
+                    backupMsg: {
+                        type: "stopBackupStore",
+                        snfloID: snfloID,
+                        time: Date.now()
+                    }
+                }
+                sendData.sign = floCrypto.signData(JSON.stringify(sendData.backupMsg), myPrivKey)
+                floGlobals.backupNodes[lastIndex].wsConn.send(JSON.stringify(sendData))
+            }
+        }
+    })
+
+    reactor.registerEvent("start_backup_store");
+    reactor.addEventListener("start_backup_store", function (event) {
+        console.log("start_backup_store :"+event.snfloID);
+        if(!floGlobals.storedList.includes(event.snfloID)){
+            floGlobals.storedList.push(event.snfloID)
+            initIndexedDBforSupernodeDataStorage(event.snfloID).then(result => {
+                reactor.dispatchEvent("request_data",{holder:event.from, snfloID:event.snfloID})
+            }).catch(error => console.log(error))
+        }
+    })
+
+    reactor.registerEvent("stop_backup_store");
+    reactor.addEventListener("stop_backup_store", function (snfloID) {
+        console.log("stop_backup_store :"+snfloID);
+        var index = floGlobals.storedList.indexOf(snfloID);
+        if (index !== -1 && snfloID !== myFloID) {
+            floGlobals.storedList.splice(index, 1);
+            compactIDB.deleteDB(`SN_${snfloID}`)
+        }
+    })
+    
+</script>
 </body>
 </html>
diff --git a/app/supernodeWSS.bin b/app/supernodeWSS.bin
new file mode 100755
index 0000000..d620c0a
Binary files /dev/null and b/app/supernodeWSS.bin differ
diff --git a/start_supernode.sh b/start_supernode.sh
new file mode 100755
index 0000000..c1b126e
--- /dev/null
+++ b/start_supernode.sh
@@ -0,0 +1,19 @@
+#!/bin/sh
+
+current_date=$(date)
+echo "$current_date : Starting Supernode" >> logs/app.log
+
+#Read configurations
+IFS="="
+while read -r var value
+do
+export "$var"="${value}"
+done < .config
+
+#Start the app
+echo $current_date >> logs/server.log
+app/supernodeWSS.bin $PORT $SERVER_PWD >> logs/server.log &
+echo $current_date >> logs/browser.log
+$BROWSER app/index.html >> logs/browser.log &
+wait
+
diff --git a/supernodeWSS b/supernodeWSS
deleted file mode 100755
index c2cc4a2..0000000
Binary files a/supernodeWSS and /dev/null differ
diff --git a/util/websocket.c b/util/websocket.c
index c5b1c2c..db6f7b2 100644
--- a/util/websocket.c
+++ b/util/websocket.c
@@ -6,9 +6,8 @@
 #include "mongoose.h"
 
 static sig_atomic_t s_signal_received = 0;
-static const char *s_http_port = "7130";
 static struct mg_serve_http_opts s_http_server_opts;
-static char server_pwd[100];
+static char *s_http_port, *server_pwd;
 static struct mg_connection *supernode_client = NULL;
 
 static void signal_handler(int sig_num) {
@@ -94,6 +93,10 @@ static void ev_handler(struct mg_connection *nc, int ev, void *ev_data) {
     case MG_EV_WEBSOCKET_HANDSHAKE_DONE: {
       /*New websocket connection*/
       display(nc, "+Connected+");
+      if(supernode_client!=NULL)
+        unicast(nc, mg_mk_str("$+"));
+      else
+        unicast(nc, mg_mk_str("$-"));
       break;
     }
     case MG_EV_WEBSOCKET_FRAME: {
@@ -106,6 +109,8 @@ static void ev_handler(struct mg_connection *nc, int ev, void *ev_data) {
         if(!strcmp(pass,server_pwd)){
           if(supernode_client!=NULL)
             unicast(supernode_client,mg_mk_str("$Another login is encountered! Please close/refresh this window"));
+          else
+            broadcast(nc, mg_mk_str("$+"));
           supernode_client = nc;
           unicast(supernode_client,mg_mk_str("$Access Granted!"));
           display(nc, "*Became SuperNode*");
@@ -129,6 +134,7 @@ static void ev_handler(struct mg_connection *nc, int ev, void *ev_data) {
       if(nc == supernode_client){
         supernode_client = NULL;
         display(nc,"!SuperNode Disconnected!");
+        broadcast(nc, mg_mk_str("$-"));
       }else
         display(nc, "-Disconnected-");
       break;
@@ -138,12 +144,8 @@ static void ev_handler(struct mg_connection *nc, int ev, void *ev_data) {
 
 int main(int argc, char** argv) {
 
-  if(argc<=1){
-    printf("Enter server password : ");
-    scanf("%s",server_pwd);
-  }
-  else
-    strcpy(server_pwd,argv[1]);
+  s_http_port = argv[1];
+  server_pwd = argv[2];
 
   struct mg_mgr mgr;
   struct mg_connection *nc;
@@ -157,7 +159,7 @@ int main(int argc, char** argv) {
 
   nc = mg_bind(&mgr, s_http_port, ev_handler);
   mg_set_protocol_http_websocket(nc);
-  s_http_server_opts.document_root = ".";  // Serve current directory
+  s_http_server_opts.document_root = "app/";  // Serve current directory
   s_http_server_opts.enable_directory_listing = "no";
 
   printf("Started on port %s\n", s_http_port);