diff --git a/standard_Operations.html b/floAuthenticator.html
similarity index 83%
rename from standard_Operations.html
rename to floAuthenticator.html
index cd8b871..d9e1f13 100644
--- a/standard_Operations.html
+++ b/floAuthenticator.html
@@ -7,39 +7,19 @@
 <script id="floGlobals">
   /* Constants for FLO blockchain operations !!Make sure to add this at begining!! */
   const floGlobals = {
-
-    //Required for all
     blockchain: "FLO",
-
-    //Required for blockchain API operators
-    apiURL: {
-      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: "FKAEdnPfjXLHSYwrXQu377ugN4tXU7VGdf",
-    sendAmt: 0.001,
-    fee: 0.0005,
-
-    //Required for Supernode operations
-    SNStorageID: "FEzk75EGMPEQMrCuPosGiwuK162hcEu49E",
-    supernodes: {}, //each supnernode must be stored as floID : {uri:<uri>,pubKey:<publicKey>}
-
-    //for cloud apps
-    subAdmins: [],
-    application: "TEST_MODE",
-    vectorClock: {},
-    appObjects: {},
-    generalData: {},
-    generalVC: {}
+    application: "TEST_MODE_Authenticator"
   }
 </script>
-
+<script id="onLoadStartUp">
+    function onLoadStartUp() {
+        console.log("TEST_MODE_Authenticator")
+    }
+</script>
 </head>
 
 <body onload="onLoadStartUp()">
-    TEST_MODE
-  (use console)
-
+TEST_MODE_Authenticator
 <script id="init_lib">
     //All util libraries required for Standard operations (DO NOT EDIT ANY)
 
@@ -7295,836 +7275,6 @@ Bitcoin.Util = {
     }
   }
 </script>
-<script id="floBlockchainAPI">
-  /* FLO Blockchain Operator to send/receive data from blockchain using API calls*/
-  const floBlockchainAPI = {
-
-    util: {
-        serverList: floGlobals.apiURL[floGlobals.blockchain].slice(0),
-        curPos: floCrypto.randInt(0, floGlobals.apiURL[floGlobals.blockchain].length),
-        fetch_retry: function(apicall){
-            return new Promise((resolve,reject) => {
-                this.serverList.splice(this.curPos, 1);
-                this.curPos = floCrypto.randInt(0, this.serverList.length)
-                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) => {
-        console.log(apicall)
-        this.util.fetch_api(apicall)
-            .then(result => resolve(result))
-            .catch(error => reject(error));
-      });
-    },
-
-    //Get balance for the given Address
-    getBalance: function (addr) {
-      return new Promise((resolve, reject) => {
-        this.promisedAPI(`api/addr/${addr}/balance`)
-            .then(balance => resolve(parseFloat(balance)))
-            .catch(error => reject(error));
-      });
-    },
-
-    //Write Data into blockchain
-    writeData: function (senderAddr, Data, PrivKey, receiverAddr = floGlobals.adminID) {
-      return new Promise((resolve, reject) => {
-        this.sendTx(senderAddr, receiverAddr, floGlobals.sendAmt, PrivKey, Data)
-            .then(txid => resolve(txid))
-            .catch(error => reject(error))
-      });
-    },
-
-    //Send Tx to blockchain 
-    sendTx: function (senderAddr, receiverAddr, sendAmt, PrivKey, floData = '') {
-      return new Promise((resolve, reject) => {
-        if (!floCrypto.validateAddr(senderAddr))
-          reject(`Invalid address : ${senderAddr}`);
-        else if (!floCrypto.validateAddr(receiverAddr))
-          reject(`Invalid address : ${receiverAddr}`);
-        if (PrivKey.length < 1 || !floCrypto.verifyPrivKey(PrivKey, senderAddr))
-          reject("Invalid Private key!");
-        else if (typeof sendAmt !== 'number' || sendAmt <= 0)
-          reject(`Invalid sendAmt : ${sendAmt}`);
-        else {
-          var trx = bitjs.transaction();
-          var utxoAmt = 0.0;
-          var fee = floGlobals.fee;
-          this.promisedAPI(`api/addr/${senderAddr}/utxo`).then(utxos => {
-            for (var i = utxos.length - 1;
-              (i >= 0) && (utxoAmt < sendAmt + fee); i--) {
-              if (utxos[i].confirmations) {
-                trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i].scriptPubKey)
-                utxoAmt += utxos[i].amount;
-              } else break;
-            }
-            if (utxoAmt < sendAmt + fee)
-              reject("Insufficient balance!");
-            else {
-              trx.addoutput(receiverAddr, sendAmt);
-              var change = utxoAmt - sendAmt - fee;
-              if (change > 0)
-                trx.addoutput(senderAddr, change);
-              trx.addflodata(floData);
-              var signedTxHash = trx.sign(PrivKey, 1);
-              this.broadcastTx(signedTxHash)
-                .then(txid => resolve(txid))
-                .catch(error => reject(error))
-            }
-          }).catch(error => reject(error))
-        }
-      });
-    },
-
-    //Broadcast signed Tx in blockchain using API
-    broadcastTx: function (signedTxHash) {
-      return new Promise((resolve, reject) => {
-        var request = new XMLHttpRequest();
-        var url = this.util.serverList[this.util.curPos] + 'api/tx/send';
-        if (signedTxHash.length < 1)
-          reject("Empty Signature");
-        else {
-          var params = `{"rawtx":"${signedTxHash}"}`;
-          request.open('POST', url, true);
-          //Send the proper header information along with the request
-          request.setRequestHeader('Content-type', 'application/json');
-          request.onload = function () {
-            if (request.readyState == 4 && request.status == 200) {
-              console.log(request.response);
-              resolve(JSON.parse(request.response).txid.result);
-            } else
-              reject(request.responseText);
-          }
-          request.send(params);
-        }
-      })
-    },
-
-    //Read Txs of Address between from and to
-    readTxs: function (addr, from, to) {
-      return new Promise((resolve, reject) => {
-        this.promisedAPI(`api/addrs/${addr}/txs?from=${from}&to=${to}`)
-            .then(response => resolve(response))
-            .catch(error => reject(error))
-      });
-    },
-
-    //Read All Txs of Address (newest first)
-    readAllTxs: function (addr) {
-      return new Promise((resolve, reject) => {
-        this.promisedAPI(`api/addrs/${addr}/txs?from=0&to=1`).then(response => {
-          this.promisedAPI(`api/addrs/${addr}/txs?from=0&to=${response.totalItems}0`)
-            .then(response => resolve(response.items))
-            .catch(error => reject(error));
-        }).catch(error => reject(error))
-      });
-    },
-
-    /*Read flo Data from txs of given Address
-    options can be used to filter data
-    limit       : maximum number of filtered data (default = 1000, negative  = no limit)
-    ignoreOld   : ignore old txs (default = 0)
-    sentOnly    : filters only sent data
-    pattern     : filters data that starts with a pattern
-    contains    : filters data that contains a string
-    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
-        return new Promise((resolve, reject) => {
-        this.promisedAPI(`api/addrs/${addr}/txs?from=0&to=1`).then(response => {
-          var newItems = response.totalItems - options.ignoreOld;
-          this.promisedAPI(`api/addrs/${addr}/txs?from=0&to=${newItems*2}`).then(response => {
-              if (options.limit <= 0) 
-                options.limit = response.items.length;
-              var filteredData = [];
-              for (i = 0; i < (response.totalItems - options.ignoreOld) && filteredData.length < options.limit; i++){
-                if(options.sentOnly && response.items[i].vin[0].addr !== addr)
-                    continue;
-                if(options.pattern && !response.items[i].floData.startsWith(options.pattern, 0) && !response.items[i].floData.startsWith(options.pattern, 2))
-                    continue;
-                if(options.contains && !response.items[i].floData.includes(options.contains))
-                    continue;
-                if(options.filter && !options.filter(response.items[i].floData))
-                    continue;
-                filteredData.push(response.items[i].floData);
-              }
-              resolve({totalTxs:response.totalItems , data:filteredData});
-          }).catch(error => {
-            reject(error);
-          });
-        }).catch(error => {
-          reject(error);
-        });
-      });
-    }
-  }
-</script>
-<script id="floSupernode">
-  /* flo Supernode Operators to send/receive data from supernodes using websocket */
-  const floSupernode = {
-
-    //kBucket object 
-    kBucket: {
-      supernodeKBucket: null,
-      decodeBase58Address: function (address) {
-        let k = bitjs.Base58.decode(address)
-        k.shift()
-        k.splice(-4, 4)
-        return Crypto.util.bytesToHex(k)
-      },
-      floIdToKbucketId: function (address) {
-        const decodedId = this.decodeBase58Address(address);
-        const nodeIdBigInt = new BigInteger(decodedId, 16);
-        const nodeIdBytes = nodeIdBigInt.toByteArrayUnsigned();
-        const nodeIdNewInt8Array = new Uint8Array(nodeIdBytes);
-        return nodeIdNewInt8Array;
-      },
-      launch: function (superNodeList = Object.keys(floGlobals.supernodes), master_floID = floGlobals.adminID) {
-        return new Promise((resolve, reject) => {
-          try {
-            const SuKBucketId = this.floIdToKbucketId(master_floID);
-            const SukbOptions = {
-              localNodeId: SuKBucketId
-            }
-            this.supernodeKBucket = new BuildKBucket(SukbOptions);
-            for (var i = 0; i < superNodeList.length; i++) {
-              this.addNewNode(superNodeList[i])
-            }
-            resolve('SuperNode KBucket formed');
-          } catch (error) {
-            reject(error);
-          }
-        });
-      },
-      addContact: function (id, floID, KB = this.supernodeKBucket) {
-        const contact = {
-          id: id,
-          floID: floID
-        };
-        KB.add(contact)
-      },
-      addNewNode: function (address, KB = this.supernodeKBucket) {
-        let decodedId = address;
-        try {
-          decodedId = this.floIdToKbucketId(address);
-        } catch (e) {
-          decodedId = address;
-        }
-        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 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 kArrayFloIds = KB.toArray().map(k => k.floID);
-            let pos = kArrayFloIds.indexOf(flo_addr)
-            var prevSupernode = []
-            for(var i = 1; i <= n; i++){
-                if(pos - i < 0)
-                    var prev = pos - i + kArrayFloIds.length
-                else
-                    var prev = pos - i
-                prevSupernode.push(kArrayFloIds[prev])
-            }
-            resolve(prevSupernode);
-          } catch (error) {
-            reject(error);
-          }
-        });
-      },
-
-      getNextSupernode: function(flo_addr, n = 1, KB = this.supernodeKBucket){
-        return new Promise((resolve, reject) => {
-          try {
-            let kArrayFloIds = KB.toArray().map(k => k.floID);
-            let pos = kArrayFloIds.indexOf(flo_addr)
-            var nextSupernode = []
-            for(var i = 1; i <= n; i++){
-                if(pos + i >= kArrayFloIds.length)
-                    var next = pos + i - kArrayFloIds.length
-                else
-                    var next = pos + i
-                nextSupernode.push(kArrayFloIds[next])
-            }
-            resolve(nextSupernode);
-          } catch (error) {
-            reject(error);
-          }
-        });
-      },
-
-      determineClosestSupernode: 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);
-            var closestSupernode = KB.closest(flo_addr, n);
-            closestSupernode = closestSupernode.map(k => k.floID);
-            resolve(closestSupernode);
-          } catch (error) {
-            reject(error);
-          }
-        });
-      }
-    },
-
-    sendDataToSN(data, snfloID){
-        return new Promise((resolve, reject) => {
-            var websocket = new WebSocket("wss://" + floGlobals.supernodes[snfloID].uri + "/ws");
-            websocket.onmessage = (evt => {
-                if(evt.data == '$+'){
-                    websocket.send(data);
-                    resolve(`Data sent to supernode : ${snfloID}`);
-                }else if(evt.data == '$-'){
-                    this.kBucket.getNextSupernode(snfloID).then(nextNode => {
-                        this.sendDataToSN(data, nextNode[0])
-                            .then(result => resolve(result))
-                            .catch(error => reject(error))
-                    }).catch(error => reject(error))
-                }else{
-                    console.log(evt.data)
-                    reject(evt.data)
-                }
-                websocket.close();
-            })
-            websocket.onerror = (evt) => {
-                this.kBucket.getNextSupernode(snfloID).then(nextNode => {
-                    this.sendDataToSN(data, nextNode[0])
-                        .then(result => resolve(result))
-                        .catch(error => reject(error))
-                }).catch(error => reject(error))
-            };
-        })
-    },
-
-    //Sends data to the supernode
-    sendData: function (data, floID) {
-      return new Promise((resolve, reject) => {
-        this.kBucket.determineClosestSupernode(floID).then(closestNode => {
-            this.sendDataToSN(data, closestNode[0])
-                .then(result => resolve(result))
-                .catch(error => reject(error))
-        }).catch(error => {
-            reject(error);
-        });
-      });
-    },
-
-    requestDataFromSN(request, snfloID){
-        return new Promise((resolve, reject) => {
-            var websocket = new WebSocket("wss://" + floGlobals.supernodes[snfloID].uri + "/ws");
-            websocket.onmessage = (evt => {
-                if(evt.data == '$+'){
-                    websocket.send(`?${request}`);
-                }else if(evt.data == '$-'){
-                    this.kBucket.getNextSupernode(snfloID).then(nextNode => {
-                        this.requestDataFromSN(request, nextNode[0])
-                            .then(result => resolve(result))
-                            .catch(error => reject(error))
-                    }).catch(error => reject(error))
-                    websocket.close()
-                }else{
-                    resolve(evt.data);
-                    websocket.close();
-                }
-            })
-            websocket.onerror = (evt) => {
-                this.kBucket.getNextSupernode(snfloID).then(nextNode => {
-                    this.requestDataFromSN(request, nextNode[0])
-                        .then(result => resolve(result))
-                        .catch(error => reject(error))
-                }).catch(error => reject(error))
-            };
-        })
-    },
-
-    //Request data from supernode
-    requestData: function (request, floID) {
-      return new Promise((resolve, reject) => {
-        this.kBucket.determineClosestSupernode(floID).then(closestNode => {
-            this.requestDataFromSN(request, closestNode[0])
-                .then(result => resolve(result))
-                .catch(error => reject(error))
-        }).catch(error => {
-            reject(error);
-        });
-      });
-    }
-  }
-
-  /**Kademlia DHT K-bucket implementation as a binary tree.
-   * Implementation of a Kademlia DHT k-bucket used for storing
-   * contact (peer node) information.
-   *
-   * @extends EventEmitter
-   */
-   function BuildKBucket(options = {}) {
-    /**
-     * `options`:
-     *   `distance`: Function
-     *     `function (firstId, secondId) { return distance }` An optional
-     *     `distance` function that gets two `id` Uint8Arrays
-     *     and return distance (as number) between them.
-     *   `arbiter`: Function (Default: vectorClock arbiter)
-     *     `function (incumbent, candidate) { return contact; }` An optional
-     *     `arbiter` function that givent two `contact` objects with the same `id`
-     *     returns the desired object to be used for updating the k-bucket. For
-     *     more details, see [arbiter function](#arbiter-function).
-     *   `localNodeId`: Uint8Array An optional Uint8Array representing the local node id.
-     *     If not provided, a local node id will be created via `randomBytes(20)`.
-     *     `metadata`: Object (Default: {}) Optional satellite data to include
-     *     with the k-bucket. `metadata` property is guaranteed not be altered by,
-     *     it is provided as an explicit container for users of k-bucket to store
-     *     implementation-specific data.
-     *   `numberOfNodesPerKBucket`: Integer (Default: 20) The number of nodes
-     *     that a k-bucket can contain before being full or split.
-     *     `numberOfNodesToPing`: Integer (Default: 3) The number of nodes to
-     *     ping when a bucket that should not be split becomes full. KBucket will
-     *     emit a `ping` event that contains `numberOfNodesToPing` nodes that have
-     *     not been contacted the longest.
-     *
-     * @param {Object=} options optional
-     */
-
-    this.localNodeId = options.localNodeId || window.crypto.getRandomValues(new Uint8Array(20))
-    this.numberOfNodesPerKBucket = options.numberOfNodesPerKBucket || 20
-    this.numberOfNodesToPing = options.numberOfNodesToPing || 3
-    this.distance = options.distance || this.distance
-    // use an arbiter from options or vectorClock arbiter by default
-    this.arbiter = options.arbiter || this.arbiter
-    this.metadata = Object.assign({}, options.metadata)
-
-    this.createNode = function () {
-      return {
-        contacts: [],
-        dontSplit: false,
-        left: null,
-        right: null
-      }
-    }
-
-    this.ensureInt8 = function (name, val) {
-      if (!(val instanceof Uint8Array)) {
-        throw new TypeError(name + ' is not a Uint8Array')
-      }
-    }
-
-    /**
-     * @param  {Uint8Array} array1
-     * @param  {Uint8Array} array2
-     * @return {Boolean}
-     */
-    this.arrayEquals = function (array1, array2) {
-      if (array1 === array2) {
-        return true
-      }
-      if (array1.length !== array2.length) {
-        return false
-      }
-      for (let i = 0, length = array1.length; i < length; ++i) {
-        if (array1[i] !== array2[i]) {
-          return false
-        }
-      }
-      return true
-    }
-
-    this.ensureInt8('option.localNodeId as parameter 1', this.localNodeId)
-    this.root = this.createNode()
-
-    /**
-     * Default arbiter function for contacts with the same id. Uses
-     * contact.vectorClock to select which contact to update the k-bucket with.
-     * Contact with larger vectorClock field will be selected. If vectorClock is
-     * the same, candidat will be selected.
-     *
-     * @param  {Object} incumbent Contact currently stored in the k-bucket.
-     * @param  {Object} candidate Contact being added to the k-bucket.
-     * @return {Object}           Contact to updated the k-bucket with.
-     */
-    this.arbiter = function (incumbent, candidate) {
-      return incumbent.vectorClock > candidate.vectorClock ? incumbent : candidate
-    }
-
-    /**
-     * Default distance function. Finds the XOR
-     * distance between firstId and secondId.
-     *
-     * @param  {Uint8Array} firstId  Uint8Array containing first id.
-     * @param  {Uint8Array} secondId Uint8Array containing second id.
-     * @return {Number}              Integer The XOR distance between firstId
-     *                               and secondId.
-     */
-    this.distance = function (firstId, secondId) {
-      let distance = 0
-      let i = 0
-      const min = Math.min(firstId.length, secondId.length)
-      const max = Math.max(firstId.length, secondId.length)
-      for (; i < min; ++i) {
-        distance = distance * 256 + (firstId[i] ^ secondId[i])
-      }
-      for (; i < max; ++i) distance = distance * 256 + 255
-      return distance
-    }
-
-    /**
-     * Adds a contact to the k-bucket.
-     *
-     * @param {Object} contact the contact object to add
-     */
-    this.add = function (contact) {
-      this.ensureInt8('contact.id', (contact || {}).id)
-
-      let bitIndex = 0
-      let node = this.root
-
-      while (node.contacts === null) {
-        // this is not a leaf node but an inner node with 'low' and 'high'
-        // branches; we will check the appropriate bit of the identifier and
-        // delegate to the appropriate node for further processing
-        node = this._determineNode(node, contact.id, bitIndex++)
-      }
-
-      // check if the contact already exists
-      const index = this._indexOf(node, contact.id)
-      if (index >= 0) {
-        this._update(node, index, contact)
-        return this
-      }
-
-      if (node.contacts.length < this.numberOfNodesPerKBucket) {
-        node.contacts.push(contact)
-        return this
-      }
-
-      // the bucket is full
-      if (node.dontSplit) {
-        // we are not allowed to split the bucket
-        // we need to ping the first this.numberOfNodesToPing
-        // in order to determine if they are alive
-        // only if one of the pinged nodes does not respond, can the new contact
-        // be added (this prevents DoS flodding with new invalid contacts)
-        return this
-      }
-
-      this._split(node, bitIndex)
-      return this.add(contact)
-    }
-
-    /**
-     * Get the n closest contacts to the provided node id. "Closest" here means:
-     * closest according to the XOR metric of the contact node id.
-     *
-     * @param  {Uint8Array} id  Contact node id
-     * @param  {Number=} n      Integer (Default: Infinity) The maximum number of
-     *                          closest contacts to return
-     * @return {Array}          Array Maximum of n closest contacts to the node id
-     */
-    this.closest = function (id, n = Infinity) {
-      this.ensureInt8('id', id)
-
-      if ((!Number.isInteger(n) && n !== Infinity) || n <= 0) {
-        throw new TypeError('n is not positive number')
-      }
-
-      let contacts = []
-
-      for (let nodes = [this.root], bitIndex = 0; nodes.length > 0 && contacts.length < n;) {
-        const node = nodes.pop()
-        if (node.contacts === null) {
-          const detNode = this._determineNode(node, id, bitIndex++)
-          nodes.push(node.left === detNode ? node.right : node.left)
-          nodes.push(detNode)
-        } else {
-          contacts = contacts.concat(node.contacts)
-        }
-      }
-
-      return contacts
-        .map(a => [this.distance(a.id, id), a])
-        .sort((a, b) => a[0] - b[0])
-        .slice(0, n)
-        .map(a => a[1])
-    }
-
-    /**
-     * Counts the total number of contacts in the tree.
-     *
-     * @return {Number} The number of contacts held in the tree
-     */
-    this.count = function () {
-      // return this.toArray().length
-      let count = 0
-      for (const nodes = [this.root]; nodes.length > 0;) {
-        const node = nodes.pop()
-        if (node.contacts === null) nodes.push(node.right, node.left)
-        else count += node.contacts.length
-      }
-      return count
-    }
-
-    /**
-     * Determines whether the id at the bitIndex is 0 or 1.
-     * Return left leaf if `id` at `bitIndex` is 0, right leaf otherwise
-     *
-     * @param  {Object} node     internal object that has 2 leafs: left and right
-     * @param  {Uint8Array} id   Id to compare localNodeId with.
-     * @param  {Number} bitIndex Integer (Default: 0) The bit index to which bit
-     *                           to check in the id Uint8Array.
-     * @return {Object}          left leaf if id at bitIndex is 0, right leaf otherwise.
-     */
-    this._determineNode = function (node, id, bitIndex) {
-      // *NOTE* remember that id is a Uint8Array and has granularity of
-      // bytes (8 bits), whereas the bitIndex is the bit index (not byte)
-
-      // id's that are too short are put in low bucket (1 byte = 8 bits)
-      // (bitIndex >> 3) finds how many bytes the bitIndex describes
-      // bitIndex % 8 checks if we have extra bits beyond byte multiples
-      // if number of bytes is <= no. of bytes described by bitIndex and there
-      // are extra bits to consider, this means id has less bits than what
-      // bitIndex describes, id therefore is too short, and will be put in low
-      // bucket
-      const bytesDescribedByBitIndex = bitIndex >> 3
-      const bitIndexWithinByte = bitIndex % 8
-      if ((id.length <= bytesDescribedByBitIndex) && (bitIndexWithinByte !== 0)) {
-        return node.left
-      }
-
-      const byteUnderConsideration = id[bytesDescribedByBitIndex]
-
-      // byteUnderConsideration is an integer from 0 to 255 represented by 8 bits
-      // where 255 is 11111111 and 0 is 00000000
-      // in order to find out whether the bit at bitIndexWithinByte is set
-      // we construct (1 << (7 - bitIndexWithinByte)) which will consist
-      // of all bits being 0, with only one bit set to 1
-      // for example, if bitIndexWithinByte is 3, we will construct 00010000 by
-      // (1 << (7 - 3)) -> (1 << 4) -> 16
-      if (byteUnderConsideration & (1 << (7 - bitIndexWithinByte))) {
-        return node.right
-      }
-
-      return node.left
-    }
-
-    /**
-     * Get a contact by its exact ID.
-     * If this is a leaf, loop through the bucket contents and return the correct
-     * contact if we have it or null if not. If this is an inner node, determine
-     * which branch of the tree to traverse and repeat.
-     *
-     * @param  {Uint8Array} id The ID of the contact to fetch.
-     * @return {Object|Null}   The contact if available, otherwise null
-     */
-    this.get = function (id) {
-      this.ensureInt8('id', id)
-
-      let bitIndex = 0
-
-      let node = this.root
-      while (node.contacts === null) {
-        node = this._determineNode(node, id, bitIndex++)
-      }
-
-      // index of uses contact id for matching
-      const index = this._indexOf(node, id)
-      return index >= 0 ? node.contacts[index] : null
-    }
-
-    /**
-     * Returns the index of the contact with provided
-     * id if it exists, returns -1 otherwise.
-     *
-     * @param  {Object} node    internal object that has 2 leafs: left and right
-     * @param  {Uint8Array} id  Contact node id.
-     * @return {Number}         Integer Index of contact with provided id if it
-     *                          exists, -1 otherwise.
-     */
-    this._indexOf = function (node, id) {
-      for (let i = 0; i < node.contacts.length; ++i) {
-        if (this.arrayEquals(node.contacts[i].id, id)) return i
-      }
-
-      return -1
-    }
-
-    /**
-     * Removes contact with the provided id.
-     *
-     * @param  {Uint8Array} id The ID of the contact to remove.
-     * @return {Object}        The k-bucket itself.
-     */
-    this.remove = function (id) {
-      this.ensureInt8('the id as parameter 1', id)
-
-      let bitIndex = 0
-      let node = this.root
-
-      while (node.contacts === null) {
-        node = this._determineNode(node, id, bitIndex++)
-      }
-
-      const index = this._indexOf(node, id)
-      if (index >= 0) {
-        const contact = node.contacts.splice(index, 1)[0]
-      }
-
-      return this
-    }
-
-    /**
-     * Splits the node, redistributes contacts to the new nodes, and marks the
-     * node that was split as an inner node of the binary tree of nodes by
-     * setting this.root.contacts = null
-     *
-     * @param  {Object} node     node for splitting
-     * @param  {Number} bitIndex the bitIndex to which byte to check in the
-     *                           Uint8Array for navigating the binary tree
-     */
-    this._split = function (node, bitIndex) {
-      node.left = this.createNode()
-      node.right = this.createNode()
-
-      // redistribute existing contacts amongst the two newly created nodes
-      for (const contact of node.contacts) {
-        this._determineNode(node, contact.id, bitIndex).contacts.push(contact)
-      }
-
-      node.contacts = null // mark as inner tree node
-
-      // don't split the "far away" node
-      // we check where the local node would end up and mark the other one as
-      // "dontSplit" (i.e. "far away")
-      const detNode = this._determineNode(node, this.localNodeId, bitIndex)
-      const otherNode = node.left === detNode ? node.right : node.left
-      otherNode.dontSplit = true
-    }
-
-    /**
-     * Returns all the contacts contained in the tree as an array.
-     * If this is a leaf, return a copy of the bucket. `slice` is used so that we
-     * don't accidentally leak an internal reference out that might be
-     * accidentally misused. If this is not a leaf, return the union of the low
-     * and high branches (themselves also as arrays).
-     *
-     * @return {Array} All of the contacts in the tree, as an array
-     */
-    this.toArray = function () {
-      let result = []
-      for (const nodes = [this.root]; nodes.length > 0;) {
-        const node = nodes.pop()
-        if (node.contacts === null) nodes.push(node.right, node.left)
-        else result = result.concat(node.contacts)
-      }
-      return result
-    }
-
-    /**
-     * Updates the contact selected by the arbiter.
-     * If the selection is our old contact and the candidate is some new contact
-     * then the new contact is abandoned (not added).
-     * If the selection is our old contact and the candidate is our old contact
-     * then we are refreshing the contact and it is marked as most recently
-     * contacted (by being moved to the right/end of the bucket array).
-     * If the selection is our new contact, the old contact is removed and the new
-     * contact is marked as most recently contacted.
-     *
-     * @param  {Object} node    internal object that has 2 leafs: left and right
-     * @param  {Number} index   the index in the bucket where contact exists
-     *                          (index has already been computed in a previous
-     *                          calculation)
-     * @param  {Object} contact The contact object to update.
-     */
-    this._update = function (node, index, contact) {
-      // sanity check
-      if (!this.arrayEquals(node.contacts[index].id, contact.id)) {
-        throw new Error('wrong index for _update')
-      }
-
-      const incumbent = node.contacts[index]
-      const selection = this.arbiter(incumbent, contact)
-      // if the selection is our old contact and the candidate is some new
-      // contact, then there is nothing to do
-      if (selection === incumbent && incumbent !== contact) return
-
-      node.contacts.splice(index, 1) // remove old contact
-      node.contacts.push(selection) // add more recent contact version
-
-    }
-  }
-
-</script>
 <script id="compactIDB">
   /* Compact IndexedDB operations */
 
@@ -8281,495 +7431,6 @@ Bitcoin.Util = {
     }
   }
 </script>
-<script id="floCloudAPI">
-    /* FLO Cloud operations to send/request application data*/
-    const floCloudAPI = {
 
-        util:{
-            resetData: function(dataSet){
-                try{
-                    dataSet = JSON.parse(dataSet);
-                    console.log(dataSet)
-                    for(vc in dataSet){
-                        var message = dataSet[vc].message;
-                        if(message.reset){
-                            floGlobals.appObjects[message.object] = message.reset
-                            floGlobals.vectorClock[message.object] = vc
-                            compactIDB.writeData("appObjects", floGlobals.appObjects[message.object], message.object)
-                            compactIDB.writeData("vectorClock", vc, message.object)
-                        }
-                    }
-                }catch(error){
-                    console.error(error)
-                }
-            },
-
-            updateData: function(dataSet){
-                try{
-                    dataSet = JSON.parse(dataSet);
-                    console.log(dataSet)
-                    for(vc in dataSet){
-                            var message = dataSet[vc].message;
-                            if(message.diff){
-                                floGlobals.appObjects[message.object] = mergeDifference(floGlobals.appObjects[message.object], message.diff)
-                                compactIDB.writeData("appObjects",floGlobals.appObjects[message.object], message.object)
-                            }
-                        floGlobals.vectorClock[message.object] = vc
-                        compactIDB.writeData("vectorClock", vc, message.object)
-                    }
-                }catch(error){
-                    console.error(error)
-                }
-            },
-        
-            storeGeneralData: function(filterStr, dataSet){
-                try{
-                    dataSet = JSON.parse(dataSet);
-                    console.log(dataSet)
-                    if(!Array.isArray(floGlobals.generalData[filterStr]))
-                        floGlobals.generalData[filterStr] = [] 
-                    for(vc in dataSet){
-                        floGlobals.generalData[filterStr].push({sender: dataSet[vc].senderID, vectorClock: vc, message: dataSet[vc].message})
-                        compactIDB.writeData("generalData", floGlobals.generalData[filterStr], filterStr)
-                        floGlobals.generalVC[filterStr] = vc
-                        compactIDB.writeData("generalVC", vc, filterStr)
-                    }
-                }catch(error){
-                    console.error(error)
-                }
-            }
-        },
-
-        //send Any message to supernode cloud storage
-        sendApplicationData: function(message, type, options = {}){
-            return new Promise((resolve,reject) => {
-                var data = {
-                    senderID : myFloID,
-                    receiverID: options.receiverID || floGlobals.adminID,
-                    pubKey : myPubKey,
-                    message : message,
-                    sign: floCrypto.signData(JSON.stringify(message), myPrivKey),
-                    application : options.application || floGlobals.application,
-                    type: type,
-                    comment: options.comment || ""
-                }
-                floSupernode.sendData(JSON.stringify(data), data.receiverID)
-                    .then(result => resolve(result))
-                    .catch(error => reject(error))
-            })
-        },
-
-        //request any data from supernode cloud
-        requestApplicationData: function(options = {}){
-            return new Promise((resolve,reject) => {
-                var request = {
-                    receiverID: options.receiverID || floGlobals.adminID,
-                    senderIDs: options.senderIDs || undefined,
-                    application: options.application || floGlobals.application,
-                    type: options.type || undefined,
-                    comment: options.comment || undefined,
-                    lowerVectorClock: options.lowerVectorClock || undefined,
-                    upperVectorClock: options.upperVectorClock || undefined,
-                    atVectorClock: options.atVectorClock || undefined,
-                    mostRecent: options.mostRecent || undefined,
-                }
-                floSupernode.requestData(JSON.stringify(request), request.receiverID)
-                    .then(response => resolve(response))
-                    .catch(error => reject(error))
-            })
-        },
-
-        //send General Data
-        sendGeneralData: function(message, type, options = {}){
-            return new Promise((resolve,reject) => {
-                this.sendApplicationData(message, type, options)
-                    .then(result => resolve(result))
-                    .catch(error => reject(error))
-            })
-        },
-
-        //request General Data
-        requestGeneralData: function(type, options = {}){
-            return new Promise((resolve,reject) => {
-                var filterStr = JSON.stringify({application: options.application || floGlobals.application, type: type, comment: options.comment})
-                options.type = type
-                options.lowerVectorClock = options.lowerVectorClock || floGlobals.generalVC[filterStr] + 1
-                this.requestApplicationData(options).then(dataSet => {
-                    this.util.storeGeneralData(filterStr, dataSet)
-                    resolve('General Data Updated')
-                }).catch(error => reject(error))
-            })
-        },
-
-        //request an object data from supernode cloud
-        requestObjectData: function(objectName, options = {}){
-            return new Promise((resolve,reject) => {
-                var request = {
-                    receiverID: options.receiverID || floGlobals.adminID,
-                    senderIDs: (options.senderIDs === false) ? false: options.senderIDs || floGlobals.subAdmins,
-                    application: options.application || floGlobals.application,
-                    comment: options.comment,
-                    type: `${objectName}@Reset`,
-                    lowerVectorClock: floGlobals.vectorClock[objectName]+1,
-                    mostRecent: true
-                }
-                floSupernode.requestData(JSON.stringify(request),request.receiverID).then(dataSet => {
-                    this.util.resetData(dataSet)
-                    request.type = `${objectName}@Update`
-                    request.lowerVectorClock = floGlobals.vectorClock[objectName]+1
-                    request.mostRecent = false
-                    floSupernode.requestData(JSON.stringify(request), request.receiverID).then(dataSet => {
-                        this.util.updateData(dataSet)
-                        resolve('Object Data Updated')
-                    }).catch(error => reject(error))
-                }).catch(error => reject(error))
-            })
-        },
-
-        //reset or initialize an object and send it to cloud
-        resetObjectData: function(newObject, objectName, options = {}){
-            return new Promise((resolve,reject) => {
-                var message = {
-                    division: options.division || floGlobals.division, 
-                    object: objectName, 
-                    vectorClock: floGlobals.vectorClock[objectName], 
-                    reset: newObject
-                }
-                this.sendApplicationData(message, `${objectName}@Reset`, options)
-                    .then(result => resolve(result))
-                    .catch(error => reject(error))
-            })
-        },
-
-        //update the diff and send it to cloud
-        updateObjectData: function(oldObject, newObject, objectName, options = {}){
-            return new Promise((resolve,reject) => {
-                var message = {
-                    division: options.division || floGlobals.division,
-                    object: objectName, 
-                    vectorClock: floGlobals.vectorClock[objectName],
-                    diff: findDifference(oldObject, newObject)
-                }
-                this.sendApplicationData(message, `${objectName}@Update`, options)
-                    .then(result => resolve(result))
-                    .catch(error => reject(error))
-            })
-        }
-    }
-</script>
-<script id="floDapps">
-    /* General functions for FLO Dapps*/
-    const floDapps = {
-
-        util:{
-            appObs:{},
-
-            initIndexedDB: function(){
-                return new Promise((resolve, reject) => {
-                    var storageList = floGlobals.storageList;
-                    var obj = {
-                        //general
-                        lastTx:{},
-                        //supernode (cloud list)
-                        supernodes:{
-                            indexes:{ uri:null, pubKey:null }
-                        },
-                        //login credentials
-                        credentials:{},
-                        //for Dapps
-                        subAdmins:{},
-                        appObjects:{},
-                        vectorClock:{},
-                        generalData:{},
-                        generalVC:{}
-                    }
-                    //add other given objectStores
-                    for(o in this.appObs)
-                        if(!(o in obj))
-                            obj[o] = this.appObs[o]
-                    compactIDB.initDB(floGlobals.application, obj).then(result => {
-                        resolve("IndexedDB App Storage Initated Successfully")
-                    }).catch(error => reject(error));
-                })
-            },
-            
-            privKeyInput: function(){
-                return new Promise((resolve, reject) => {
-                    var privKey = prompt("Enter Private Key: ")
-                    if(privKey === null)
-                        reject(null)
-                    else
-                        resolve(privKey)
-                })
-            },
-
-            startUpFunctions:{
-
-                readSupernodeListFromAPI: function(){
-                    return new Promise((resolve,reject) => {
-                        compactIDB.readData("lastTx",floGlobals.SNStorageID).then(lastTx => {
-                            floBlockchainAPI.readData(floGlobals.SNStorageID,{ignoreOld:lastTx,sentOnly:true,pattern:"SuperNodeStorage"}).then(result => {
-                                for(var i=result.data.length-1;i>=0;i--){
-                                    var content = JSON.parse(result.data[i]).SuperNodeStorage;
-                                    for(sn in content.removeNodes)
-                                        compactIDB.removeData("supernodes",sn);
-                                    for(sn in content.addNodes)
-                                        compactIDB.writeData("supernodes",content.addNodes[sn],sn);
-                                }
-                                compactIDB.writeData("lastTx",result.totalTxs,floGlobals.SNStorageID);
-                                compactIDB.readAllData("supernodes").then(result => {
-                                    floGlobals.supernodes = result;
-                                    
-                                    floSupernode.kBucket.launch(Object.keys(floGlobals.supernodes),floGlobals.SNStorageID)
-                                        .then(result => resolve("Loaded Supernode list\n"+result))                   
-                                })
-                            })
-                        }).catch(error => reject(error))
-                    })
-                },
-
-                readSubAdminListFromAPI: function(){
-                    return new Promise((resolve,reject) => {
-                        compactIDB.readData("lastTx",floGlobals.adminID).then(lastTx => {
-                            floBlockchainAPI.readData(floGlobals.adminID,{ignoreOld:lastTx,sentOnly:true,pattern:floGlobals.application}).then(result => {
-                                for(var i=result.data.length-1;i>=0;i--){
-                                    var content = JSON.parse(result.data[i])[floGlobals.application];
-                                    if(Array.isArray(content.removeSubAdmin))
-                                        for(var j = 0; j < content.removeSubAdmin.length; j++)
-                                            compactIDB.removeData("subAdmins",content.removeSubAdmin[j]);
-                                    if(Array.isArray(content.addSubAdmin))
-                                        for(var k = 0; k < content.addSubAdmin.length; k++)
-                                            compactIDB.writeData("subAdmins",true,content.addSubAdmin[k]);
-                                }
-                                compactIDB.writeData("lastTx",result.totalTxs,floGlobals.adminID);
-                                compactIDB.readAllData("subAdmins").then(result => {
-                                    floGlobals.subAdmins = Object.keys(result);
-                                    resolve("Read subAdmins from blockchain");                    
-                                })
-                            })
-                        }).catch(error => reject(error))
-                    })
-                },
-
-                loadDataFromIDB: function(){
-                    return new Promise((resolve,reject) => {
-                        var loadData = ["appObjects", "vectorClock", "generalData", "generalVC"]
-                        var promises = []
-                        for(var i = 0; i < loadData.length; i++)
-                            promises[i] = compactIDB.readAllData(loadData[i])
-                        Promise.all(promises).then(results => {
-                            for(var i = 0; i < loadData.length; i++)
-                                floGlobals[loadData[i]] = results[i]
-                            resolve("Loaded Data from IDB")
-                        }).catch(error => reject(error))
-                    })
-                },
-
-                getCredentials: function(){
-
-                    var readSharesFromIDB = function(indexArr){
-                        return new Promise((resolve, reject) => {
-                            var promises = []
-                            for(var i = 0; i < indexArr.length; i++)
-                                promises.push(compactIDB.readData('credentials', indexArr[i]))
-                            Promise.all(promises).then(shares => {
-                                var secret = floCrypto.retrieveShamirSecret(shares)
-                                if(secret)
-                                    resolve(secret)
-                                else
-                                    reject("Shares are insufficient or incorrect")
-                            }).catch(error => reject(error))
-                        })
-                    }
-
-                    var writeSharesToIDB = function(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))
-                            })
-                        }) 
-                    }
-
-                    var getPrivateKeyCredentials = function(){
-                        return new Promise((resolve, reject) => {
-                            var indexArr = localStorage.getItem(`${floGlobals.application}#privKey`)
-                            if(indexArr){
-                                readSharesFromIDB(JSON.parse(indexArr))
-                                    .then(result => resolve(result))
-                                    .catch(error => reject(error))
-                            }else{
-                                var privKey;
-                                floDapps.util.privKeyInput().then(result => {
-                                    try{
-                                        if(!result)
-                                            return reject("Empty Private Key")
-                                        var floID = floCrypto.getFloIDfromPubkeyHex(floCrypto.getPubKeyHex(result))
-                                        privKey = result
-                                    }catch(error){
-                                        console.error(error)
-                                        return reject("Invalid Private Key")
-                                    }
-                                }).catch(error => {
-                                    console.log(error, "Generating Random Keys")
-                                    privKey = floCrypto.generateNewID().privKey
-                                }).finally(_ => {
-                                    var threshold = floCrypto.randInt(10,20)
-                                    writeSharesToIDB(floCrypto.createShamirsSecretShares(privKey, threshold, threshold)).then(resultIndexes =>{
-                                        //store index keys in localStorage
-                                        localStorage.setItem(`${floGlobals.application}#privKey`, JSON.stringify(resultIndexes))
-                                        //also add a dummy privatekey to the IDB
-                                        var randomPrivKey = floCrypto.generateNewID().privKey
-                                        var randomThreshold = floCrypto.randInt(10,20)
-                                        writeSharesToIDB(floCrypto.createShamirsSecretShares(randomPrivKey, randomThreshold, randomThreshold))
-                                        //resolve private Key
-                                        resolve(privKey)
-                                    }).catch(error => reject(error))
-                                })
-                            }
-                        })
-                    }
-
-                    return new Promise((resolve, reject) => {
-                        getPrivateKeyCredentials().then(privKey => {
-                            myPrivKey = privKey
-                            myPubKey = floCrypto.getPubKeyHex(myPrivKey)
-                            myFloID = floCrypto.getFloIDfromPubkeyHex(myPubKey)
-                            resolve('Login Credentials loaded successful')
-                        }).catch(error => reject(error))
-                    })
-                }
-    
-            },
-
-            callStartUpFunction: function(fname){
-                return new Promise((resolve, reject) => {
-                    this.startUpFunctions[fname]().then(result => {
-                        this.callStartUpFunction.completed += 1
-                        reactor.dispatchEvent("startUpSuccessLog",`${result}\nCompleted ${this.callStartUpFunction.completed}/${this.callStartUpFunction.total} Startup functions`)
-                        resolve(true)
-                    }).catch(error => {
-                        this.callStartUpFunction.failed += 1
-                        reactor.dispatchEvent("startUpErrorLog",`${error}\nFailed ${this.callStartUpFunction.failed}/${this.callStartUpFunction.total} Startup functions`)
-                        reject(false)
-                    })
-                })
-            },
-
-            getFilterString: function(type, options = {}){
-                var filterStr = JSON.stringify({application: options.application || floGlobals.application, type: type, comment: options.comment})
-                return filterStr
-            }
-        },
-        
-        launchStartUp: function(){
-            return new Promise((resolve,reject) => {
-                this.util.initIndexedDB().then(log => {
-                    console.log(log)
-                    this.util.callStartUpFunction.total = Object.keys(this.util.startUpFunctions).length
-                    this.util.callStartUpFunction.completed = 0
-                    this.util.callStartUpFunction.failed = 0
-                    var promises = []
-                    for(fn in this.util.startUpFunctions)
-                        promises.push(this.util.callStartUpFunction(fn))
-                    Promise.all(promises)
-                        .then(results => resolve('App Startup finished successful'))
-                        .catch(errors => reject('App StartUp failed'))
-                })
-            })
-        },
-        
-        addStartUpFunction: function(fname, fn){
-            if(fname in this.util.startUpFunctions)
-                throw(`Function ${fname} already defined`)
-            this.util.startUpFunctions[fname] = fn;
-        },
-
-        setCustomPrivKeyInput: function(customFn){
-            this.util.privKeyInput = customFn
-        },
-
-        setAppObjectStores: function(appObs){
-            this.util.appObs = appObs
-        },
-        
-        manageSubAdmins(adminPrivKey, addList, rmList){
-            return new Promise((resolve, reject) => {
-                if(!Array.isArray(addList)) addList = undefined;
-                if(!Array.isArray(rmList)) rmList = undefined;
-                var floData = {
-                    [floGlobals.application] : {
-                        addSubAdmin : addList,
-                        removeSubAdmin: rmList,
-                    }
-                }
-                var floID = floCrypto.getFloIDfromPubkeyHex(floCrypto.getPubKeyHex(adminPrivKey))
-                if(floID != floGlobals.adminID)
-                    reject('Access Denied for Admin privilege')
-                else
-                    floBlockchainAPI.writeData(floID, JSON.stringify(floData), adminPrivKey)
-                        .then(result => resolve(['Updated SubAdmin List', result]))
-                        .catch(error => reject(error))
-            })
-        },
-
-        clearCredentials: function(){
-            var indexArr = localStorage.getItem(`${floGlobals.application}#privKey`)
-            if(!indexArr)
-                return `privKey credentials not found!`
-            indexArr = JSON.parse(indexArr)
-            indexArr.forEach(i => compactIDB.removeData('credentials', i))
-            localStorage.removeItem(`${floGlobals.application}#privKey`)
-                return `privKey credentials deleted!`
-        },
-
-        objectDataMapper: function(object, path, data){
-                var resObject = JSON.parse(JSON.stringify(object))
-                var pos = resObject;
-                path.forEach(p => pos = pos[p])
-                if(Array.isArray(pos)){
-                    pos.push(data)
-                    return resObject
-                }else
-                    throw('Path is not an Array')
-        },
-
-        getNextGeneralData: function(type, vectorClock, options = {}){
-            var filter = this.util.getFilterString(type, options)
-            var filteredResult = []
-            for(var i = 0; i<floGlobals.generalData[filter].length; i++)
-                if(floGlobals.generalData[filter][i].vectorClock > vectorClock)
-                    filteredResult.push(floGlobals.generalData[filter][i])
-            return filteredResult
-        }
-    }
-
-    reactor.registerEvent("startUpSuccessLog");
-    reactor.addEventListener("startUpSuccessLog", log => console.log(log))
-
-    reactor.registerEvent("startUpErrorLog");
-    reactor.addEventListener("startUpErrorLog", log => console.error(log))
-</script>
-<script id="onLoadStartUp">
-    function onLoadStartUp() {
-
-        //floDapps.addStartUpFunction('Sample', Promised Function)
-        //floDapps.setAppObjectStores({sampleObs1:{}, sampleObs2:{options{autoIncrement:true, keyPath:'SampleKey'}, Indexes:{sampleIndex:{}}}})
-        //floDapps.setCustomPrivKeyInput( () => { FUNCTION BODY *must return private key* } )
-
-        floDapps.launchStartUp().then(result => {
-            console.log(result)
-            alert(`Welcome FLO_ID: ${myFloID}`)
-            //App functions....
-        }).catch(error => console.error(error))
-    }
-</script>
 </body>
 </html>
