diff --git a/.gitignore b/.gitignore
index 452463b..0409579 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,5 +9,6 @@ supernode/test/in/index4.html
 supernode/flosend.html
 supernode/index1 (copy).html
 supernode/websocket_chat
+supernode/cash_payments_handler2.html
 .vscode/
 supernode/test/
diff --git a/supernode/cash_payments_handler.html b/supernode/cash_payments_handler.html
index 5de0170..a63fa19 100644
--- a/supernode/cash_payments_handler.html
+++ b/supernode/cash_payments_handler.html
@@ -129,18 +129,10 @@
         <div class="collapse navbar-collapse" id="navbarCollapse">
           <ul class="navbar-nav mr-auto">
             <li class="nav-item active">
-              <a class="nav-link" href="#"
-                >Home <span class="sr-only">(current)</span></a
-              >
-            </li>
             <li class="nav-item">
-              <a class="nav-link" href="#">Link</a>
-            </li>
-            <li class="nav-item">
-              <a class="nav-link" href="#">Disabled</a>
+              <a class="nav-link" href="#" id="flo_keys_reset">Reset Account</a>
             </li>
           </ul>
-          <div id="conn_info"></div>
         </div>
       </nav>
     </header>
@@ -174,72 +166,91 @@
         This page is to be used by <code>Localbitcoinplusplus Cashiers</code> as a tool
         to manage cash deposits and withdraws.
       </p>
+      
+      <div class="card" id="manual_token_transfer_div">
+          <div class="card-body">
+                <h4 class="alert alert-light" role="alert">
+                    Manual Token Transfer 
+                </h4>
+                <p><label for="token_receiver">Receiver Flo Address </label>
+                <input type="text" id="token_receiver"></p>
+                <p><label for="token_name">Choose Token: </label>
+                <input type="radio" id="token_name" name="transfer_token_name" value="rupee"> Rupee </p>
+                <p><label for="token_amount">Amount of Tokens to transfer: </label>
+                <input type="number" id="token_amount"></p>
+                <p><input type="button" class="btn btn-outline-primary" id="send_tokens_btn" value="Send Tokens"></p>
+          </div>
+      </div>
 
-      <div class="row" id="supernode_seeds_div"></div>
-      <div class="row" id="flo_keys_div"></div>
-      <div class="row" id="pending_deposits_list"></div>
+      <!-- <div class="card">
+          <div class="card-body" id="pending_deposits_list"></div>
+      </div> -->
 
       <!-- Pending Deposits -->
-      <div class="row">
-        <h4 class="alert alert-light" role="alert">
-          Cash Deposit Requests List
-        </h4>
-        <input
-          type="text"
-          id="searchbar_deposits"
-          class="myInput"
-          onkeyup="search_deposits()"
-          placeholder="Search anything"
-        />
-        <button
-          type="button"
-          class="btn btn-outline-primary"
-          id="fetch_deposits"
-        >
-          Load Pending Cash Deposits
-        </button>
-
-        <table id="deposits_list" class="myTable">
-          <tr class="header">
-            <th>User UPI Id</th>
-            <th>User FLO Id</th>
-            <th>Depositing Amount</th>
-            <th>Currency</th>
-            <th>Action</th>
-          </tr>
-        </table>
+      <div class="card">
+        <div class="card-body">
+            <h4 class="alert alert-light" role="alert">
+              Cash Deposit Requests List
+            </h4>
+            <input
+              type="text"
+              id="searchbar_deposits"
+              class="myInput"
+              onkeyup="search_deposits()"
+              placeholder="Search anything"
+            />
+            <button
+              type="button"
+              class="btn btn-outline-primary"
+              id="fetch_deposits"
+            >
+              Load Pending Cash Deposits
+            </button>
+    
+            <table id="deposits_list" class="myTable">
+              <tr class="header">
+                <th>User UPI Id</th>
+                <th>User FLO Id</th>
+                <th>Depositing Amount</th>
+                <th>Currency</th>
+                <th>Action</th>
+              </tr>
+            </table>
+        </div>  
       </div>
 
       <!-- Pending Withdrawals -->
-      <div class="row">
-        <h4 class="alert alert-light" role="alert">
-          Cash Withdrawals Requests List
-        </h4>
-        <input
-          type="text"
-          id="searchbar_withdraws"
-          class="myInput"
-          onkeyup="search_withdraws()"
-          placeholder="Search anything"
-        />
-        <button
-          type="button"
-          class="btn btn-outline-primary"
-          id="fetch_withdraws"
-        >
-          Load Pending Cash Withdrawals
-        </button>
-
-        <table id="withdraws_list" class="myTable">
-          <tr class="header">
-            <th>User UPI Id</th>
-            <th>User FLO Id</th>
-            <th>Withdrawal Amount</th>
-            <th>Currency</th>
-            <th>Txid</th>
-            <th>Action</th>
-          </tr>
-        </table>
+      <div class="card">
+        <div class="card-body">
+            <h4 class="alert alert-light" role="alert">
+              Cash Withdrawals Requests List
+            </h4>
+            <input
+              type="text"
+              id="searchbar_withdraws"
+              class="myInput"
+              onkeyup="search_withdraws()"
+              placeholder="Search anything"
+            />
+            <button
+              type="button"
+              class="btn btn-outline-primary"
+              id="fetch_withdraws"
+            >
+              Load Pending Cash Withdrawals
+            </button>
+    
+            <table id="withdraws_list" class="myTable">
+              <tr class="header">
+                <th>User UPI Id</th>
+                <th>User FLO Id</th>
+                <th>Withdrawal Amount</th>
+                <th>Currency</th>
+                <th>Txid</th>
+                <th>Action</th>
+              </tr>
+            </table>
+        </div>
       </div>
     </main>
 
@@ -8338,13 +8349,34 @@
         // 52 characters base58
         ECKey.isCompressedWalletImportFormat = function(key) {
           key = key.toString();
-          return ECKey.privateKeyPrefix == 0x80
-            ? /^[LK][123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{51}$/.test(
-                key
-              )
-            : /^c[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{51}$/.test(
-                key
-              );
+        //   return ECKey.privateKeyPrefix == 0x80
+        //     ? /^[LK][123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{51}$/.test(
+        //         key
+        //       )
+        //     : /^c[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{51}$/.test(
+        //         key
+        //       );
+            switch (ECKey.currentBlockchain) {
+              case "BTC":
+                  return /^[LK][123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{51}$/.test(
+                        key
+                    )
+                  break;              
+              case "BTC_TEST":
+                  return /^c[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{51}$/.test(
+                        key
+                    );   
+                  break;
+              case "FLO":
+                  return /^R[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{51}$/.test(key);
+                  break;              
+              case "FLO_TEST":
+                  return /^c[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{51}$/.test(key);
+                  break;
+          
+              default:
+                  break;
+          }
         };
 
         // 44 characters
@@ -11334,14 +11366,15 @@
     <!-- CASH PAYMENTS HANDLER SCRIPT START -->
 
     <script>
-      (function payments_handler() {
+      //(function payments_handler() {
         /* CODE_JUNCTION: localbitcoinplusplus object init */
 
         var localbitcoinplusplus = {
           wallets: {},
           trade: {},
           rpc: {},
-          master_configurations: {}
+          master_configurations: {},
+          supernode_conns: {},
         };
 
         Object.defineProperty(localbitcoinplusplus, "server", {
@@ -11352,7 +11385,18 @@
             btc_testnet: "https://test-insight.bitpay.com",
             flo_mainnet: "http://flosight.duckdns.org",
             //flo_testnet: "http://testnet-flosight.duckdns.org"
-            flo_testnet: "https://testnet.flocha.in"
+            flo_testnet: "https://testnet.flocha.in",
+            flo_api_testnet: "https://ranchimallflo-testnet.duckdns.org",
+          },
+          writable: false,
+          configurable: false,
+          enumerable: false
+        });
+
+        Object.defineProperty(localbitcoinplusplus, "assets", {
+          value: {
+              BTC: "BTC_TEST",
+              FLO: "FLO_TEST"
           },
           writable: false,
           configurable: false,
@@ -11920,6 +11964,26 @@
 
         localbitcoinplusplus.actions = {
           parse_flo_comments: async function(callback) {
+            text = `masterFLOPubKey=03EA5E2CAB18DA585400D6EC569438D415FAF200528E05D0E2B9BEAA2B5C3DCA90
+            #!#tradableAsset1=BTC,FLO,BTC_TEST,FLO_TEST#!#tradableAsset2=INR,USD,
+            #!#validTradingAmount=10,50,100,#!#btcTradeMargin=5000
+            #!#MaxBackups=1
+            #!#miners_fee={"btc":0.0003, "flo":0.0003}
+            #!#supernodesPubKeys=0315C3A20FE7096CC2E0F81A80D5F1A687B8F9EFA65242A0B0881E1BA3EE7D7D53,
+            03F7493F11B8E44B9798CD434D20FBE7FA34B9779D144984889D11A17C56A18742,039B4AA00DBFC0A6631DE6DA83526611A0E6B857D3579DF840BBDEAE8B6898E3B6,
+            03C8E3836C9A77E2AF03D4265D034BA85732738919708EAF6A16382195AE796EDF,0349B08AA1ABDCFFB6D78CD7C949665AD2FF065EA02B3C6C47A5E9592C9A1C6BCB,
+            026FCC6CFF6EB3A39E54BEB6E13FC2F02C3A93F4767AA80E49E7E876443F95AE5F,
+            #!#assets={"BTC":"BTC_TEST","FLO":"FLO_TEST"}
+            #!#externalFiles={"d3js":"58f54395efa8346e8e94d12609770f66b916897e7f4e05f6c98780cffa5c70a3"}
+            #!#cashiers={"032871A74D2DDA9D0DE7135F58B5BD2D7F679D2CCA20EA7909466D1A6912DF4022":"johnDoe@upi",
+            "03DB4A12EB543B293DDBB0CE314C46C36D6761294AFBB7264A6D78F710FFD97CF0":"janeDoe@upi"}
+            #!#ShamirsMaxShares=8#!#supernodeSeeds={"ranchimall1":{"ip":"127.0.0.1","port":"9111","kbucketId":"oZxHcbSf1JC8t5GjutopWYXs7C6Fe9p7ps"},
+            "ranchimall2":{"ip":"127.0.0.1","port":"9112","kbucketId":"oTWjPupy3Z7uMdPcu5uXd521HBkcsLuSuM"},
+            "ranchimall3":{"ip":"127.0.0.1","port":"9113","kbucketId":"odYA6KagmbokSh9GY7yAfeTUZRtZLwecY1"},
+            "ranchimall4":{"ip":"127.0.0.1","port":"9114","kbucketId":"oJosrve9dBv2Hj2bfncxv2oEpTysg3Wejv"},
+            "ranchimall5":{"ip":"127.0.0.1","port":"9115","kbucketId":"oMhv5sAzqg77sYHxmUGZWKRrVo4P4JQduS"},
+            "ranchimall6":{"ip":"127.0.0.1","port":"9116","kbucketId":"oV1wCeWca3VawbBTfUGKA7Vd368PATnKAx"}}`;
+            return callback(text);
             const master_data = await helper_functions
             .ajaxGet(`${localbitcoinplusplus.server.flo_testnet}/api/txs/?address=${localbitcoinplusplus.RM_FLO_SENDING_ADDR}`);
                 if(typeof master_data==="object" && typeof master_data.txs==="object") {
@@ -12023,9 +12087,11 @@
               );
             // changesMadeByAbhishek: Change private key prefix before initing key
             Bitcoin.ECKey.privateKeyPrefix = privKeyPrefix;
+            Bitcoin.ECKey.currentBlockchain = crypto;
             var key = new Bitcoin.ECKey(privateKey);
 
-            key.setCompressed(true);
+            if(key.compressed!==true) key.setCompressed(true);  
+
             var privateKeyHex = key.getBitcoinHexFormat();
             var privateKeyWIF = key.getBitcoinWalletImportFormat();
 
@@ -12044,7 +12110,7 @@
               address
             };
           },
-          sign: function(msg, privateKeyHex) {
+          sign: function(msg, privateKeyHex, crypto = "FLO_TEST") {
             if (crypto == "BTC") {
               privKeyPrefix = 0x80; //mainnet 0x80, testnet: 0xEF
               networkVersion = 0x00; //mainnet 0x23, testnet: 0x6F
@@ -12143,7 +12209,7 @@
                   typeof usr == "object" &&
                   usr.myLocalFLOAddress.length > 0
                 ) {
-                  const RM_WALLET = new localbitcoinplusplus.wallets();
+                  //const RM_WALLET = new localbitcoinplusplus.wallets();
                   const pk_manual = prompt("Please enter your private key: ");
                   let gen_new_keys = this.generateFloKeys(pk_manual);
                   if (gen_new_keys.address == usr.myLocalFLOAddress) {
@@ -12202,7 +12268,169 @@
               privateKeyDecimal: privateKeyDecimal,
               privateKeyHex: privateKeyHex
             };
-          }
+          },
+          sendTransaction(
+            crypto_type,
+            utxo_addr,
+            utxo_addr_wif,
+            receiver_address,
+            receiving_amount,
+            change_adress,
+            custom_floData = ""
+          ) {
+            return new Promise((resolve, reject)=>{
+
+            let blockchain_explorer;
+            let miners_fee = 0.0003;
+            const miner_fee_obj = localbitcoinplusplus.master_configurations.miners_fee;
+            if (crypto_type == "BTC") {
+                blockchain_explorer = localbitcoinplusplus.server.btc_mainnet;
+                miners_fee = miner_fee_obj.btc;
+            } else if (crypto_type == "BTC_TEST") {
+                blockchain_explorer = localbitcoinplusplus.server.btc_testnet;
+                miners_fee = miner_fee_obj.btc;
+            } else if (crypto_type == "FLO") {
+                blockchain_explorer = localbitcoinplusplus.server.flo_mainnet;
+                miners_fee = miner_fee_obj.flo;
+            } else if (crypto_type == "FLO_TEST") {
+                blockchain_explorer = localbitcoinplusplus.server.flo_testnet;
+                miners_fee = miner_fee_obj.flo;
+            }
+
+            if (typeof blockchain_explorer !== "string") {
+                showMessage(
+                    `WARNING: Please select cryptocurrency/fiat value from select bar.`
+                );
+                return false;
+            }
+
+            let url = `${blockchain_explorer}/api/addr/${utxo_addr}/utxo`;
+            console.log(url);
+            let err_msg;
+
+            helper_functions
+                .ajaxGet(url)
+                .then(utxo_list => {
+                    if (utxo_list.length > 0) {
+                        try {
+                            let btc_eq_receiving_amount = Number(receiving_amount);
+                            btc_eq_receiving_amount = Number(
+                                btc_eq_receiving_amount.toFixed(8)
+                            );
+
+                            let trx = bitjs[crypto_type].transaction();
+                            let sum = 0;
+
+                            for (var key in utxo_list) {
+                                if (utxo_list[key].confirmations !== 0) {
+                                    var obj = utxo_list[key];
+                                    sum += obj.amount;
+
+                                    if (btc_eq_receiving_amount <= sum) {
+                                        trx.addinput(obj.txid, obj.vout, obj.scriptPubKey);
+                                        break;
+                                    } else {
+                                        trx.addinput(obj.txid, obj.vout, obj.scriptPubKey);
+                                    }
+                                }
+                            }
+
+                            if (sum <= 0) {
+                                console.log(utxo_list);
+                                throw new Error("ERROR: No amount found in UTXO.");
+                            }
+
+                            // Output cannot be greater than input
+                            if (sum < btc_eq_receiving_amount) {
+                                btc_eq_receiving_amount = sum;
+                            }
+
+                            if (btc_eq_receiving_amount - miners_fee <= 0)
+                                throw new Error(
+                                    `Error: btc_eq_receiving_amount cannot be less than miners_fee.`
+                                );
+
+                            btc_eq_receiving_amount =
+                                btc_eq_receiving_amount - miners_fee;
+                            btc_eq_receiving_amount = Number(
+                                btc_eq_receiving_amount.toFixed(8)
+                            );
+                            trx.addoutput(receiver_address, btc_eq_receiving_amount);
+
+                            let change_amount = 0;
+                            if (sum - btc_eq_receiving_amount - miners_fee > 0) {
+                                change_amount = sum - btc_eq_receiving_amount - miners_fee;
+                                change_amount = Number(change_amount.toFixed(8));
+                            }
+
+                            if (change_amount > 0) {
+                                trx.addoutput(change_adress, change_amount);
+                            }
+                            var sendFloData = `localbitcoinpluslus tx: Send ${btc_eq_receiving_amount} ${crypto_type} to ${receiver_address}.`; //flochange adding place for flodata -- need a validation of 1024 chars
+                            if (custom_floData.length > 0) {
+                                sendFloData = custom_floData;
+                            }
+                            if (crypto_type == "FLO" || crypto_type == "FLO_TEST") {
+                                trx.addflodata(sendFloData); // flochange .. create this function
+                            }
+
+                            try {
+                                console.log(trx);
+
+                                let signedTxHash = trx.sign(utxo_addr_wif, 1); //SIGHASH_ALL DEFAULT 1
+                                showMessage(`Signed Transaction Hash: ${signedTxHash}`);
+                                console.log(signedTxHash);
+
+                                var http = new XMLHttpRequest();
+                                var tx_send_url = `${blockchain_explorer}/api/tx/send`;
+                                var params = `{"rawtx":"${signedTxHash}"}`;
+                                http.open("POST", tx_send_url, true);
+                                http.setRequestHeader("Content-type", "application/json");
+                                http.onreadystatechange = function () {
+                                    //Call a function when the state changes.
+                                    if (http.readyState == 4) {
+                                        if (http.status == 200) {
+                                            console.log(http.responseText);
+                                            let response_obj = {
+                                                signedTxHash: signedTxHash,
+                                                txid: http.responseText
+                                            };
+                                            resolve(response_obj);
+                                        } else {
+                                            let response_obj = {
+                                                signedTxHash: signedTxHash,
+                                                txid: ""
+                                            };
+                                            resolve(response_obj);
+                                        }
+                                    }
+                                };
+                                http.onerror = function () {
+                                    let response_obj = {
+                                        signedTxHash: signedTxHash,
+                                        txid: ""
+                                    };
+                                    resolve(response_obj);
+                                };
+                                http.send(params);
+                            } catch (error) {
+                                showMessage(error);
+                                reject(error);
+                                throw new Error(error);
+                            }
+                        } catch (error) {
+                            reject(error);
+                            throw new Error(error);
+                        }
+                    }
+                })
+                .catch(e =>
+                    console.error(
+                        `ERROR: Failed to send tx from utxo ${utxo_addr}: ${e}`
+                    )
+                );
+            });
+            },
         };
 
         /* CODE_JUNCTION: RPC */
@@ -12255,7 +12483,7 @@
                 "string" &&
               localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY.length > 0
             ) {
-              const RM_WALLET = new localbitcoinplusplus.wallets();
+              //const RM_WALLET = new localbitcoinplusplus.wallets();
               let user_keys = RM_WALLET.generateFloKeys(
                 localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY
               );
@@ -12299,8 +12527,8 @@
             var method = request.method;
 
             if (typeof params == "object" && typeof method == "string") {
-              const RM_WALLET = new localbitcoinplusplus.wallets();
-              const RM_RPC = new localbitcoinplusplus.rpc();
+              //const RM_WALLET = new localbitcoinplusplus.wallets();
+              //const RM_RPC = new localbitcoinplusplus.rpc();
 
               let respective_trader_id = "";
               if (typeof params.trader_flo_address == "string")
@@ -12655,7 +12883,7 @@
             if (typeof myPrivateKey !== "string")
               throw new Error("No private key found.");
 
-            const RM_WALLET = new localbitcoinplusplus.wallets();
+            //const RM_WALLET = new localbitcoinplusplus.wallets();
             let privateKey = RM_WALLET.wifToDecimal(myPrivateKey, true);
             if (typeof privateKey.privateKeyDecimal !== "string")
               throw new Error("Failed to detremine your private key.");
@@ -12674,6 +12902,9 @@
           }
         };
 
+        const RM_WALLET = new localbitcoinplusplus.wallets();
+        const RM_RPC = new localbitcoinplusplus.rpc();
+        
         /* CODE_JUNCTION: Indexed DB */
 
         //prefixes of implementation that we want to test
@@ -12974,38 +13205,31 @@
 
         /* CODE_JUNCTION: Websockets */
 
-        function startWebSocket(wsUri) {
+        async function initializeWebSocket(wsUri){
+            var websocket = new WebSocket(wsUri);
+            return websocket;
+        }
+
+        function startWebSocket(websocket_name) {
           return new Promise((resolve, reject) => {
-            websocket = new WebSocket(wsUri);
-            websocket.onopen = function(evt) {
+             
+            websocket_name.onopen = function(evt) {
               resolve(onOpen(evt));
             };
-            websocket.onclose = function(evt) {
+            websocket_name.onclose = function(evt) {
               reject(onClose(evt));
             };
-            websocket.onmessage = function(evt) {
+            websocket_name.onmessage = function(evt) {
               resolve(onMessage(evt));
             };
-            websocket.onerror = function(evt) {
+            websocket_name.onerror = function(evt) {
               reject(onError(evt));
             };
           });
         }
 
         function onOpen(evt) {
-          readAllDB("supernodesList").then(list => {
-            list.some(m => {
-              let ws_res = `ws://${m.ip}:${m.port}/`;
-              if (ws_res == websocket.url)
-                localbitcoinplusplus.CONNECTED_SUPERNODE_FLO_ADDRESS =
-                  m.kbucketId;
-            });
-          });
           console.info(`INFO: Connected succesfully to ${evt.srcElement.url}.`);
-          let conn_info = document.getElementById("conn_info");
-          conn_info.innerHTML = `<div class="alert alert-success" role="alert">
-                                        INFO: Connected to ${evt.srcElement.url} Supernode.
-                                        </div>`;
         }
 
         function onClose(event) {
@@ -13022,121 +13246,238 @@
           }
         }
 
+        function onMessageAcceptTest(testName, testParameters) {
+            if (testName == "whetherForCashier") {
+                let is_message_for_cashier = testParameters.data.search("__FOR__CASHIER__");
+                if (is_message_for_cashier < 0) {
+                    return false;
+                } else return true;
+            }
+            if (testName == "amISuperNode") {
+                if (testParameters.supernodesPubKeys.includes(testParameters.my_local_flo_public_key)) {
+                    return true;
+                } else return false;
+            }
+            if (testName == "meInReceiverList") {
+                if (testParameters.receiversList.includes(testParameters.my_local_flo_address)) {
+                    return true;
+                } else return false;
+            }
+            if (testName == "checkIfObject") {
+                if (typeof testParameters.data !== "object") {
+                    return false;
+                } else return true;
+            }
+            if (testName == "receiverIDisMine") {
+                return testParameters.receiverFloId === localbitcoinplusplus.wallets.my_local_flo_address;
+            }
+            if (testName == "beforePrivateKeyEntry") {
+                return testParameters.methodList.includes(testParameters.method);
+            }
+            if(testName == "senderAddressMatchesSignerAddress") {
+                return testParameters.calculatedFloId === testParameters.senderFloId;
+            }
+            if(testName == "verifyMessageSignature") {
+                const initialMsgObjStr = JSON.stringify(testParameters.initialMsgObj);
+
+                const initialMsgObjStrHash = Crypto.SHA256(initialMsgObjStr);
+
+                //const RM_WALLET = new [testParameters.verifierObject]();
+                if (RM_WALLET.verify(
+                        initialMsgObjStrHash,
+                        testParameters.signedMsg,
+                        testParameters.publicKey
+                    )
+                ) {
+                    return true;
+                } else return false;
+            }
+            if(testName == "isDataString") {
+                return typeof testParameters.param === "string";
+            }
+            if(testName == "isValueUnDefined") {
+                return typeof testParameters.param === "undefined";
+            }
+        }
+
+        //HANDLER OUTSIDE
+        function onMessageDataHandling(handlerName,data){
+
+            if (handlerName == "extractMainObject") {
+
+            var res_pos = data.indexOf("{");
+            if (res_pos >= 0) {
+                var res = data.substr(res_pos);
+            }
+
+            return res;
+            }
+        }
+
+        function onMessageResponse(responseName, responseData) {
+            if(responseName==="list_of_cashier_latest_pending_cash_deposits") {
+                let response_from_server = responseData.responseData;
+                    
+                if (
+                    typeof response_from_server.data == "object" &&
+                    response_from_server.data.length > 0
+                ) {
+                    onMessageDisplay("list_of_cashier_latest_pending_cash_deposits", {
+                        responseData: response_from_server
+                    });
+                } else {
+                    showMessage(`INFO: No pending deposits found.`);
+                }
+            }
+
+            if(responseName==="list_of_cashier_latest_pending_cash_withdrawals") {
+                let response_from_server = responseData.responseData;
+                if (
+                    typeof response_from_server.data == "object" &&
+                    response_from_server.data.length > 0
+                ) {
+                    onMessageDisplay("list_of_cashier_latest_pending_cash_withdrawals", {
+                        responseData: response_from_server
+                    });
+                } else {
+                    showMessage(`INFO: No pending withdrawals found.`);
+                }
+            }
+        }
+
+        function onMessageDisplay(responseName, responseData) {
+            switch (responseName) {
+                case "list_of_cashier_latest_pending_cash_deposits":
+                    (async function() {
+                        let t = ``;
+                        let deposits_table = document.getElementById("deposits_list");
+                        for (const m of responseData.responseData.data) {
+                            let su_res = await localbitcoinplusplus.kademlia.determineClosestSupernode(m.trader_flo_address);
+                            let closestSupernode = su_res[0].data.id;
+                            t += `<tr id='tr_${m.id}'>`;
+                            t += `<td> ${m.user_upi} </td>`;
+                            t += `<td> ${m.trader_flo_address} </td>`;
+                            t += `<td> ${m.depositing_amount} </td>`;
+                            t += `<td> ${m.currency} </td>`;
+                            t += `<td> <button type="button" value="${m.id}" class="btn btn-info cnf_deposits">Deposit Received!</button> 
+                                <input type="hidden" id="depositSpan${m.id}" value="${closestSupernode}_${responseData.responseData.requesting_supernode}">
+                                </td>`;
+                            t += `</tr>`;
+                        }
+                        deposits_table.insertAdjacentHTML("beforeend", t);
+                        confirmDepositReceivedFromUser();
+                    })();
+                    break;
+
+                case "list_of_cashier_latest_pending_cash_withdrawals":
+                    (async function() {
+                        let v = ``;
+                        const withdraws_table = document.getElementById("withdraws_list");
+                        for (const m of responseData.responseData.data) {
+                            const user_upi = localbitcoinplusplus.encrypt.decryptMessage(
+                                m.receivinAddress.secret,
+                                m.receivinAddress.senderPublicKeyString
+                            );
+                            let su_res = await localbitcoinplusplus.kademlia.determineClosestSupernode(m.trader_flo_address);
+                            let closestSupernode = su_res[0].data.id;
+
+                            v += `<tr>`;
+                            v += `<td> ${user_upi} </td>`;
+                            v += `<td> ${m.trader_flo_address} </td>`;
+                            v += `<td> ${m.withdraw_amount} </td>`;
+                            v += `<td> ${m.currency} </td>`;
+                            v += `<td> ${m.token_transfer_txid} </td>`;
+                            v += `<td> <button type="button" value="${m.id}" class="btn btn-info cnf_withdrawal">Money Transferred!</button> 
+                                <input type="hidden" id="withdrawSpan${m.id}" value="${closestSupernode}_${responseData.responseData.requesting_supernode}">
+                                </td>`;
+                            v += `</tr>`;
+                        }
+                        withdraws_table.insertAdjacentHTML("beforeend", v);
+                        confirmCashierTransferredMoneyToWithdrawer();
+                    })();
+                break;
+            
+                default:
+                    break;
+            }
+        }
+ 
         async function onMessage(evt) {
           var response = evt.data || evt;
-
-          let is_message_for_cashier = response.search("__FOR__CASHIER__");
-          if (is_message_for_cashier < 0) return;
+          console.log(response);
+          if (!onMessageAcceptTest("whetherForCashier", {searchString:"__FOR__CASHIER__",data:response})) return;  
 
           console.log("RESPONSE: " + response);
 
-          var res_pos = response.indexOf("{");
-          if (res_pos >= 0) {
-            var res = response.substr(res_pos);
+          //var res_pos = response.indexOf("{");
+          var res = onMessageDataHandling("extractMainObject", response);
+
             try {
               var res_obj = JSON.parse(res);
 
-              if (
-                typeof res_obj.globalParams !== "object" ||
-                (localbitcoinplusplus.master_configurations.supernodesPubKeys.includes(
-                  localbitcoinplusplus.wallets.my_local_flo_public_key
-                ) &&
-                  typeof res_obj.globalParams.receiversList == "object" &&
-                  !res_obj.globalParams.receiversList.includes(
-                    localbitcoinplusplus.wallets.my_local_flo_address
-                  ))
-              )
-                return;
+            if(!onMessageAcceptTest("checkIfObject", {
+                data:res_obj.globalParams,
+            })) return;
 
-              if (
-                typeof res_obj.globalParams.receiverFloId == "string" &&
-                res_obj.globalParams.receiverFloId !==
-                  localbitcoinplusplus.wallets.my_local_flo_address
-              )
-                return;
+            if(onMessageAcceptTest("amISuperNode", 
+            {supernodesPubKeys:
+                localbitcoinplusplus.master_configurations.supernodesPubKeys,
+            my_local_flo_public_key:
+                localbitcoinplusplus.wallets.my_local_flo_public_key
+            })) return;
 
-              const isIncomingMessageValid = await validateIncomingMessage(res);
-              console.log("isIncomingMessageValid: ", isIncomingMessageValid);
+            if(onMessageAcceptTest("checkIfObject", {
+                    data:res_obj.globalParams.receiversList,
+                }) 
+            ) {
+                if(!onMessageAcceptTest("meInReceiverList", {
+                    receiversList:res_obj.globalParams.receiversList,
+                    my_local_flo_address:localbitcoinplusplus.wallets.my_local_flo_address
+                })) return;
+            }
 
-              if (!isIncomingMessageValid) return;
+            if(!onMessageAcceptTest("receiverIDisMine", {
+                receiverFloId:res_obj.globalParams.receiverFloId,
+            })) return;
 
-              if (typeof res_obj.globalParams.senderFloId !== "string")
-                throw new Error(
-                  `WARNING: The request did not contain sender FLO Id. Request Aborted.`
-                );
+            const isIncomingMessageValid = await validateIncomingMessage(res);
+            console.log("isIncomingMessageValid: ", isIncomingMessageValid);
+
+            if (!isIncomingMessageValid) return;
+
+            if(!onMessageAcceptTest("isDataString", {
+                param:res_obj.globalParams.senderFloId,
+            })) return;
+
+            if(onMessageAcceptTest("isValueUnDefined", {
+                param: res_obj.method
+            })) return;
 
-              if (typeof res_obj.method !== "undefined") {
                 let response_from_sever;
 
-                const RM_WALLET = new localbitcoinplusplus.wallets();
-                const RM_RPC = new localbitcoinplusplus.rpc();
-
                 switch (res_obj.method) {
                   case "list_of_cashier_latest_pending_cash_deposits":
-                    response_from_sever = res_obj.params[0];
-                    if (
-                      typeof response_from_sever.data == "object" &&
-                      response_from_sever.data.length > 0
-                    ) {
-                      const deposits_table = document.getElementById(
-                        "deposits_list"
-                      );
-                      let t = ``;
-                      response_from_sever.data.map(m => {
-                        t += `<tr>`;
-                        t += `<td> ${m.user_upi} </td>`;
-                        t += `<td> ${m.trader_flo_address} </td>`;
-                        t += `<td> ${m.depositing_amount} </td>`;
-                        t += `<td> ${m.currency} </td>`;
-                        t += `<td> <button type="button" value="${m.id}" class="btn btn-info cnf_deposits">Deposit Received!</button> </td>`;
-                        t += `</tr>`;
+        
+                      onMessageResponse("list_of_cashier_latest_pending_cash_deposits", {
+                        responseData: res_obj.params[0]
                       });
-                      deposits_table.insertAdjacentHTML("beforeend", t);
-                      confirmDepositReceivedFromUser();
-                    } else {
-                      showMessage(`INFO: No pending deposits found.`);
-                    }
+
                     break;
                   case "list_of_cashier_latest_pending_cash_withdrawals":
-                    response_from_sever = res_obj.params[0];
-                    if (
-                      typeof response_from_sever.data == "object" &&
-                      response_from_sever.data.length > 0
-                    ) {
-                      const withdraws_table = document.getElementById(
-                        "withdraws_list"
-                      );
-                      let t = ``;
-                      response_from_sever.data.map(m => {
-                        const user_upi = localbitcoinplusplus.encrypt.decryptMessage(
-                          response_from_sever.data[0].receivinAddress.secret,
-                          response_from_sever.data[0].receivinAddress
-                            .senderPublicKeyString
-                        );
-                        t += `<tr>`;
-                        t += `<td> ${user_upi} </td>`;
-                        t += `<td> ${m.trader_flo_address} </td>`;
-                        t += `<td> ${m.withdraw_amount} </td>`;
-                        t += `<td> ${m.currency} </td>`;
-                        t += `<td> ${m.token_transfer_txid} </td>`;
-                        t += `<td> <button type="button" value="${m.id}" class="btn btn-info cnf_withdrawal">Money Transferred!</button> </td>`;
-                        t += `</tr>`;
-                      });
-                      withdraws_table.insertAdjacentHTML("beforeend", t);
-                      confirmCashierTransferredMoneyToWithdrawer();
-                    } else {
-                      showMessage(`INFO: No pending withdrawals found.`);
-                    }
+                    
+                    onMessageResponse("list_of_cashier_latest_pending_cash_withdrawals", {
+                        responseData: res_obj.params[0]
+                    });
                     break;
 
                   default:
                     break;
                 }
-              }
+              
             } catch (e) {
               throw new Error(e);
             }
-          }
+          
         }
 
         function onError(evt) {
@@ -13145,12 +13486,12 @@
           );
         }
 
-        function doSend(message = "") {
+        function doSend(websocket_name, message = "") {
           let finalMessage = message;
 
           const msgObj = JSON.parse(message);
 
-          const RM_WALLET = new localbitcoinplusplus.wallets();
+          //const RM_WALLET = new localbitcoinplusplus.wallets();
 
           message = JSON.stringify(msgObj);
           const message256hash = Crypto.SHA256(message);
@@ -13175,7 +13516,7 @@
 
           // The message is for usernodes and all backup supernodes
           try {
-            websocket.send(finalMessage);
+            websocket_name.send(finalMessage);
           } catch (error) {
             throw new Error(error);
           }
@@ -13196,17 +13537,19 @@
             try {
               const msgObj = JSON.parse(message);
 
-              if (request_array.includes(msgObj.method)) return resolve(true);
+              //if (request_array.includes(msgObj.method)) return resolve(true);
+              if (onMessageAcceptTest("beforePrivateKeyEntry", {"methodList":request_array,"method":msgObj.method})) return resolve(true);
 
-              const getFloId = bitjs.FLO_TEST.pubkey2address(msgObj.nodePubKey);
+              //const getFloId = bitjs.FLO_TEST.pubkey2address(msgObj.nodePubKey);
+              const getFloId = bitjs[localbitcoinplusplus.assets.FLO].pubkey2address(msgObj.nodePubKey);
 
-              // Check if the public key belongs to real sender
-              if (getFloId !== msgObj.globalParams.senderFloId) {
+              if (!onMessageAcceptTest("senderAddressMatchesSignerAddress", {"senderFloId":msgObj.globalParams.senderFloId,"calculatedFloId":getFloId})) {
                 showMessage(
-                  `Sender FLO address did not match signer FLO address.`
+                `Sender FLO address did not match signer FLO address.`
                 );
                 reject(false);
               }
+             
               const initialMsgObj = {
                 jsonrpc: msgObj.jsonrpc,
                 id: msgObj.id,
@@ -13215,18 +13558,12 @@
                 globalParams: msgObj.globalParams
               };
 
-              const initialMsgObjStr = JSON.stringify(initialMsgObj);
-
-              const initialMsgObjStrHash = Crypto.SHA256(initialMsgObjStr);
-
-              const RM_WALLET = new localbitcoinplusplus.wallets();
-              if (
-                RM_WALLET.verify(
-                  initialMsgObjStrHash,
-                  msgObj.nodeSignedMessage,
-                  msgObj.nodePubKey
-                )
-              ) {
+              if (onMessageAcceptTest("verifyMessageSignature", {
+                  "initialMsgObj":initialMsgObj,
+                  "verifierObject": localbitcoinplusplus.wallets,
+                  "signedMsg": msgObj.nodeSignedMessage,
+                  "publicKey": msgObj.nodePubKey
+                  })) {
                 resolve(true);
               } else {
                 showMessage(
@@ -13300,6 +13637,12 @@
           };
         }
 
+        function delay(t, v) {
+          return new Promise(function(resolve) {
+            setTimeout(resolve.bind(null, v), t);
+          });
+        }
+
         function duplicatesInArray(arr) {
           arr.reduce(function(acc, el, i, arr) {
             if (arr.indexOf(el) !== i && acc.indexOf(el) < 0) acc.push(el);
@@ -13332,142 +13675,163 @@
 
         // Connect to Supernode
         function loadSupernodesConnectUi() {
-          let supernodeSeedsObj =
+            let supernodeSeedsObj =
             localbitcoinplusplus.master_configurations.supernodeSeeds;
-          let supernodeSeedsArray = Object.values(supernodeSeedsObj);
-
-          let supernode_seedsInput = ``;
-          supernode_seedsInput += `<div class="input-group">
-                        <select class="custom-select" id="supernode_seeds">
-                            <option selected>Choose Suprnode...</option>`;
-          supernodeSeedsArray.map(wsUri => {
-            supernode_seedsInput += `<option value="ws://${wsUri.ip}:${wsUri.port}">${wsUri.kbucketId}</option>`;
-          });
-          supernode_seedsInput += `</select>
-                        <div class="input-group-append">
-                            <button class="btn btn-outline-secondary" id="supn_conn_btn" type="button">Connect</button>
-                        </div>
-                     </div>`;
-
-          const supernode_seeds_div = document.getElementById(
-            "supernode_seeds_div"
-          );
-          supernode_seeds_div.innerHTML = supernode_seedsInput;
-
-          const supn_conn_btn = document.getElementById("supn_conn_btn");
-          supn_conn_btn.addEventListener("click", function(evt) {
-            const selected_su = document.getElementById("supernode_seeds");
-            if (
-              typeof websocket == "object" &&
-              websocket.readyState === WebSocket.OPEN
-            ) {
-              if (websocket.url === `${selected_su.value}/`) {
-                showMessage(`INFO: Websocket already connected.`);
-                return;
-              }
-              websocket.close();
-            }
-
-            try {
-              startWebSocket(selected_su.value);
-            } catch (error) {
-              showMessage("Error: " + error);
-              return;
-            }
+            let supernodeSeedsArray = Object.values(supernodeSeedsObj);
+          supernodeSeedsArray.map(async wsUri => {
+            localbitcoinplusplus.supernode_conns[wsUri.kbucketId] = await initializeWebSocket (`ws://${wsUri.ip}:${wsUri.port}`);
+            startWebSocket(localbitcoinplusplus.supernode_conns[wsUri.kbucketId]);
           });
         }
 
+        function send_deposit_withdraw_req_loop() {
+            let supernodeSeedsObj =
+            localbitcoinplusplus.master_configurations.supernodeSeeds;
+            let supernodeSeedsArray = Object.values(supernodeSeedsObj);
+            const btn_id = this.id;
+            if (typeof btn_id !== "string") return;
+            let job = "";
+            if (btn_id == "fetch_deposits") {
+                job = "give_cashier_latest_pending_cash_deposits";
+            } else if (btn_id == "fetch_withdraws") {
+                job = "give_cashier_latest_pending_cash_withdraws";
+            } else return;
+            supernodeSeedsArray.map(async wsUri => {
+                send_deposit_withdraw_req(wsUri.kbucketId, job);
+            });
+        }
+
         // Fetch Deposit or Withdraw requests
-        function send_deposit_withdraw_req(evt) {
-          evt.preventDefault();
-          if (
-            localbitcoinplusplus.MY_UPI_ID.length < 1 
-            || typeof localbitcoinplusplus.CONNECTED_SUPERNODE_FLO_ADDRESS !== "string"
-            || localbitcoinplusplus.CONNECTED_SUPERNODE_FLO_ADDRESS.length < 1
-          ) {
+        function send_deposit_withdraw_req(websocket_flo_id="", job="", parent_flo_id="") {
+          if (localbitcoinplusplus.MY_UPI_ID.length < 1) {
             showMessage(
-              `WARNING: Your UPI Id or connected Supernode is not set.`
+              `WARNING: Your UPI Id is not set.`
             );
             return false;
           }
 
-          const btn_id = this.id;
-          if (typeof btn_id !== "string") return;
-          let job = "";
-          if (btn_id == "fetch_deposits") {
-            job = "give_cashier_latest_pending_cash_deposits";
-          } else if (btn_id == "fetch_withdraws") {
-            job = "give_cashier_latest_pending_cash_withdraws";
-          } else return;
+          const websocket_name = localbitcoinplusplus.supernode_conns[websocket_flo_id];
+          if(typeof websocket_name!=="object") return;
 
-          const RM_RPC = new localbitcoinplusplus.rpc();
-          RM_RPC.send_rpc
-            .call(this, job, {
+          if(job.length<1) return;
+
+          let req_body = {
               trader_flo_address:
                 localbitcoinplusplus.wallets.my_local_flo_address,
               cashier_pubKey:
                 localbitcoinplusplus.wallets.my_local_flo_public_key,
               cashier_upi: localbitcoinplusplus.MY_UPI_ID,
-              receiver_flo_address:
-                localbitcoinplusplus.CONNECTED_SUPERNODE_FLO_ADDRESS
-            })
-            .then(resp => doSend(resp));
+              receiver_flo_address: websocket_flo_id,
+            }
+
+          // For case where parent supernode is dead  
+          if(websocket_flo_id !== parent_flo_id && parent_flo_id.length>0) {
+            req_body.parent_supernode = parent_flo_id;
+            req_body.requesting_supernode = websocket_flo_id;
+          }  
+
+          if(parent_flo_id.length<1 || websocket_flo_id==parent_flo_id) {
+            req_body.parent_supernode = websocket_flo_id;
+            req_body.requesting_supernode = websocket_flo_id;              
+          }
+
+          RM_RPC.send_rpc
+            .call(this, job, req_body)
+            .then(resp => doSend(websocket_name, resp));
         }
 
         // Ask Connected Supernode to give pending deposits/withdrawals
         function AskSupernodeForLatestDepositsAndWithdrawalsData() {
           const fetch_deposits_btn = document.getElementById("fetch_deposits");
-          const fetch_withdraws_btn = document.getElementById(
-            "fetch_withdraws"
-          );
+          const fetch_withdraws_btn = document.getElementById("fetch_withdraws");
 
           fetch_deposits_btn.addEventListener(
             "click",
-            send_deposit_withdraw_req
+            send_deposit_withdraw_req_loop
           );
           fetch_withdraws_btn.addEventListener(
             "click",
-            send_deposit_withdraw_req
+            send_deposit_withdraw_req_loop
           );
         }
 
         function confirmDepositReceivedFromUser() {
           const recv_deposit_btn = document.getElementsByClassName("cnf_deposits");
-          
+          const RM_WALLET = new localbitcoinplusplus.wallets;
           Array.from(recv_deposit_btn).forEach(function(element) {
-            element.addEventListener("click", function(evt) {
-                evt.preventDefault();
+            element.addEventListener("click", async function(evt) {
+                //evt.preventDefault();
                 const deposit_id = this.value;
-                console.log(deposit_id);
+                const req_info = document.getElementById(`depositSpan${deposit_id}`);
+                const req_info_arr = req_info.value.split("_");
+                const websocket_name = req_info_arr[0];
+                const requesting_supernode = req_info_arr[1];
 
-                const flo_txid = prompt("Enter Deposit Token Transfer Flo Txid: ");
-                if (flo_txid.length < 1) return;
+                const depositorInfo = document.getElementById(`tr_${deposit_id}`);
+                const depositorInfoVals = depositorInfo.getElementsByTagName('td');
+                const token_transfer_statement = `transfer ${depositorInfoVals[2].innerText} rupee# on behalf of ${depositorInfoVals[1].innerText}`;
+                const tx_amount = 0.001;
 
-                let cash_recvd_from_user = prompt(
-                "Enter Amount Received in Cash: "
+                if(typeof websocket_name!=="string" || typeof requesting_supernode!=="string") return;
+
+                const confirmTx = confirm(token_transfer_statement);
+                if(!confirmTx) return;
+
+                const websocket_conn = localbitcoinplusplus.supernode_conns[requesting_supernode];
+                if(typeof websocket_conn!=="object") return;
+
+                let flo_txid = '';
+
+                const flo_tx = await RM_WALLET.sendTransaction(
+                    localbitcoinplusplus.assets.FLO,
+                    localbitcoinplusplus.wallets.my_local_flo_address,
+                    localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY,
+                    requesting_supernode,
+                    tx_amount,
+                    localbitcoinplusplus.wallets.my_local_flo_address,
+                    token_transfer_statement
                 );
-                cash_recvd_from_user = Number(cash_recvd_from_user);
-                if (
-                    cash_recvd_from_user === NaN ||    
-                    typeof cash_recvd_from_user !== "number" ||
-                    cash_recvd_from_user < 1
-                )
-                return;
+                if (typeof flo_tx.txid == "string" &&
+                    flo_tx.txid.length > 0
+                ) {
+                    resp_obj = JSON.parse(flo_tx.txid);
+                    flo_txid = resp_obj.txid.result || resp_obj.txid;
+                }
+                if (typeof flo_txid!=="string" || flo_txid.length < 1) return;
 
-                const RM_RPC = new localbitcoinplusplus.rpc();
-                RM_RPC.send_rpc
-                .call(this, "cashier_confirms_user_cash_deposit", {
+                let req_body = {
                     trader_flo_address:
                     localbitcoinplusplus.wallets.my_local_flo_address,
                     cashier_pubKey:
                     localbitcoinplusplus.wallets.my_local_flo_public_key,
-                    receiver_flo_address:
-                    localbitcoinplusplus.CONNECTED_SUPERNODE_FLO_ADDRESS,
+                    receiver_flo_address: requesting_supernode,
                     flo_txid: flo_txid,
                     deposit_id: deposit_id,
-                    cash_deposited: cash_recvd_from_user
-                })
-                .then(resp => doSend(resp));
+                    parent_supernode: websocket_name,
+                }
+
+                const txidUrlDeposit = `${localbitcoinplusplus.server
+                    .flo_api_testnet}/api/v1.0/getTransactionDetails/${flo_txid}`;
+                let n=1;
+                (async function validateTxidInBlockchain() {
+                    // Validate Flo txid
+                    await delay(120000); 
+                    const validate_flo_txid = await helper_functions.ajaxGet(txidUrlDeposit);
+                    console.log(validate_flo_txid);
+                    if(typeof validate_flo_txid == "object"
+                    && typeof validate_flo_txid.transactionDetails == "object"
+                    && typeof validate_flo_txid.transactionDetails.floData == "string"
+                    && validate_flo_txid.transactionDetails.floData.length > 5 // without ':text'
+                    ) {
+                        RM_RPC.send_rpc
+                        .call(this, "cashier_confirms_user_cash_deposit", req_body)
+                        .then(resp => doSend(websocket_conn, resp));
+                    } else if(n<=10) {
+                        validateTxidInBlockchain();
+                        n++;
+                    } else throw new Error(`Failed to inform Supernode of cash deposit: ${flo_txid}`);
+                })()
+
             });
             });
         
@@ -13481,47 +13845,103 @@
               element.addEventListener("click", function(evt) {
                   evt.preventDefault();
                   const withdraw_id = this.value;
-                  console.log(withdraw_id);
-                  
+                  const req_info = document.getElementById(`withdrawSpan${withdraw_id}`);
+                  const req_info_arr = req_info.value.split("_");
+                  const websocket_name = req_info_arr[0];
+                  const requesting_supernode = req_info_arr[1];
+
+                  if(typeof websocket_name!=="string" || typeof requesting_supernode!=="string") return;
+
                   const upi_txid = prompt("Enter Transferred Cash UPI Txid: ");
                   if (upi_txid.length < 1) return;
+
+                  const websocket_conn = localbitcoinplusplus.supernode_conns[requesting_supernode];
+                  if(typeof websocket_conn!=="object") return;
                   
-                  const RM_RPC = new localbitcoinplusplus.rpc();
                   RM_RPC.send_rpc
                   .call(this, "cashier_confirms_user_cash_withdraw", {
                       trader_flo_address:
                       localbitcoinplusplus.wallets.my_local_flo_address,
                       cashier_pubKey:
                       localbitcoinplusplus.wallets.my_local_flo_public_key,
-                      receiver_flo_address:
-                      localbitcoinplusplus.CONNECTED_SUPERNODE_FLO_ADDRESS,
+                      receiver_flo_address: requesting_supernode,
                       withdraw_id: withdraw_id,
-                      upi_txid: upi_txid
+                      upi_txid: upi_txid,
+                      parent_supernode: websocket_name,
                     })
-                    .then(resp => doSend(resp));
+                    .then(resp => doSend(websocket_conn, resp));
                 });
             });
         }
 
+        async function transferTokensManually() {
+            try {                    
+                send_tokens_btn.onclick = function() {
+                    return new Promise(async (resolve, reject)=>{
+                        const token_sender = localbitcoinplusplus.wallets.my_local_flo_address;
+                        const token_receiver = document.getElementById('token_receiver').value;
+                        const send_tokens_btn = document.getElementById('send_tokens_btn');
+                        const token_amount = Number(document.getElementById('token_amount').value);
+                        const token_name_radio = document.querySelector('input[name="transfer_token_name"]:checked').value;            
+                        
+                        const flo_comment = `transfer ${token_amount} ${token_name}# to ${token_receiver}`;                
+                        const token_balance_url = `${localbitcoinplusplus.server.flo_api_testnet}/api/v1.0/getFloAddressBalance?token=${token_name}&floAddress=${token_sender}`;
+                        const sender_token_balance = await helper_functions.ajaxGet(token_balance_url);
+                        let err_msg = '';
+
+                        if(typeof sender_token_balance!=="object" 
+                        || typeof sender_token_balance.balance!=="number"
+                        || sender_token_balance.balance<token_amount) {
+                            err_msg = `INFO: Sender has insufficient ${token_name} balance.`;
+                            showMessage(err_msg);
+                            return false;
+                        }
+                        let flo_txid = '';
+                        const RM_WALLET = new localbitcoinplusplus.wallets;
+                        const flo_tx = await RM_WALLET.sendTransaction(
+                            localbitcoinplusplus.assets.FLO,
+                            localbitcoinplusplus.wallets.my_local_flo_address,
+                            localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY,
+                            token_receiver,
+                            token_amount,
+                            localbitcoinplusplus.wallets.my_local_flo_address,
+                            flo_comment
+                        );
+                        if (typeof flo_tx.txid == "string" &&
+                            flo_tx.txid.length > 0
+                        ) {
+                            resp_obj = JSON.parse(flo_tx.txid);
+                            flo_txid = resp_obj.txid.result || resp_obj.txid;
+                        }
+                        if (typeof flo_txid!=="string" || flo_txid.length < 1) {
+                            err_msg = `Error: Failed to broadcast token transfer transaction.`; 
+                            showMessage(err_msg);
+                            reject(err_msg);
+                        } else {
+                            showMessage(`INFO: Successful token transfer txid: ${flo_txid}`);
+                            showMessage(`INFO: ${token_amount} ${token_name} transferred to ${token_receiver}.`);
+                            resolve(flo_txid);
+                        }
+                    })
+                }
+
+            } catch (error) {
+                throw new Error(error);
+            }
+        }
+
         // Reset Flo Id
         function loadResetFloBtnUi() {
           // RESET KEYS
-          const reset_flo_keys_div = document.getElementById("flo_keys_div");
-          const reset_flo_keys_btn = document.createElement("button");
-          reset_flo_keys_btn.className += ` button bg-purple mg-5 `;
-          const reset_flo_keys_btn_text = document.createTextNode(
-            `Reset FLO Keys`
-          );
-          reset_flo_keys_btn.appendChild(reset_flo_keys_btn_text);
-          reset_flo_keys_div.appendChild(reset_flo_keys_btn);
-
+          const reset_flo_keys_btn = document.getElementById("flo_keys_reset");
+          
           reset_flo_keys_btn.onclick = function() {
             if (
               confirm(
                 `This will reset your old keys along with data associated with it. Are you sure you want to continue?`
               )
             ) {
-              const RM_WALLET = new localbitcoinplusplus.wallets();
+              //const RM_WALLET = new localbitcoinplusplus.wallets();
               RM_WALLET.reset_flo_keys().then(reset_success => {
                 if (reset_success) {
                   showMessage("INFO: FLO keys have been reset successfully.");
@@ -13537,9 +13957,6 @@
         const dataBaseUIOperations = async function() {
           localbitcoinplusplus.is_ui_loaded = true;
 
-          const RM_WALLET = new localbitcoinplusplus.wallets();
-          const RM_RPC = new localbitcoinplusplus.rpc();
-
           try {
             readDB("paymentsHandlerDetails", "00-01").then(async function(
               idbData
@@ -13572,7 +13989,7 @@
 
         function kickInit() {
           output = document.getElementById("output_div");
-          const RM_WALLET = new localbitcoinplusplus.wallets();
+          //const RM_WALLET = new localbitcoinplusplus.wallets();
           return new Promise(resolve => {
             readDB("paymentsHandlerDetails", "00-01").then(async function(
               idbData
@@ -13654,6 +14071,9 @@
                     dataBaseUIOperations();
                   }
 
+                  // load token transfer ui
+                  transferTokensManually();
+
                   resolve(true);
                   return;
                 } else {
@@ -13706,11 +14126,14 @@
                 dataBaseUIOperations();
               }
 
+              // load token transfer ui
+              transferTokensManually();
+
               resolve(true);
             });
           });
         }
-      })();
+      //})();
     </script>
 
     <script>
@@ -13783,20 +14206,5 @@
       }
     </script>
 
-    <script
-      src="https://code.jquery.com/jquery-3.2.1.slim.min.js"
-      integrity="sha384-KJ3o2DKtIkvYIK3UENzmM7KCkRr/rE9/Qpg6aAZGJwFDMVNA/GpGFF93hXpG5KkN"
-      crossorigin="anonymous"
-    ></script>
-    <script
-      src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.12.9/umd/popper.min.js"
-      integrity="sha384-ApNbgh9B+Y1QKtv3Rn7W3mgPxhU9K/ScQsAP7hUibX39j7fakFPskvXusvfa0b4Q"
-      crossorigin="anonymous"
-    ></script>
-    <script
-      src="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/js/bootstrap.min.js"
-      integrity="sha384-JZR6Spejh4U02d8jOt6vLEHfe/JQGiRRSQQxSfFWpi1MquVdAyjUar5+76PVCmYl"
-      crossorigin="anonymous"
-    ></script>
   </body>
 </html>
diff --git a/supernode/index.html b/supernode/index.html
index af9d208..eaa8993 100644
--- a/supernode/index.html
+++ b/supernode/index.html
@@ -8450,6 +8450,9 @@
                 bytes = Crypto.util.hexToBytes(input);
               } else if (ECKey.isBase64Format(input)) {
                 bytes = Crypto.util.base64ToBytes(input);
+              } else {
+                bytes = ECKey.decodeCompressedWalletImportFormat(input);
+                this.compressed = true;
               }
             } catch (exc1) {
               this.setError(exc1);
@@ -8746,13 +8749,29 @@
         // 52 characters base58
         ECKey.isCompressedWalletImportFormat = function(key) {
           key = key.toString();
-          return ECKey.privateKeyPrefix == 0x80
-            ? /^[LK][123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{51}$/.test(
-                key
-              )
-            : /^c[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{51}$/.test(
-                key
-              );
+
+          switch (ECKey.currentBlockchain) {
+              case "BTC":
+                  return /^[LK][123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{51}$/.test(
+                        key
+                    )
+                  break;              
+              case "BTC_TEST":
+                  return /^c[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{51}$/.test(
+                        key
+                    );   
+                  break;
+              case "FLO":
+                  return /^R[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{51}$/.test(key);
+                  break;              
+              case "FLO_TEST":
+                  return /^c[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{51}$/.test(key);
+                  break;
+          
+              default:
+                  break;
+          }
+
         };
 
         // 44 characters
@@ -11514,7 +11533,9 @@
           btc_testnet: "https://test-insight.bitpay.com",
           flo_mainnet: "http://flosight.duckdns.org",
           //flo_testnet: "http://testnet-flosight.duckdns.org"
-          flo_testnet: "https://testnet.flocha.in"
+          flo_testnet: "https://testnet.flocha.in",
+          flo_api_testnet: "https://ranchimallflo-testnet.duckdns.org",
+          //flo_api_testnet: "ranchimall1.duckdns.org:5109"
         },
         writable: false,
         configurable: false,
@@ -12077,7 +12098,7 @@
             026FCC6CFF6EB3A39E54BEB6E13FC2F02C3A93F4767AA80E49E7E876443F95AE5F,
             #!#externalFiles={"d3js":"58f54395efa8346e8e94d12609770f66b916897e7f4e05f6c98780cffa5c70a3"}
             #!#cashiers={"032871A74D2DDA9D0DE7135F58B5BD2D7F679D2CCA20EA7909466D1A6912DF4022":"johnDoe@upi",
-            "janeDoe@upi":"03DB4A12EB543B293DDBB0CE314C46C36D6761294AFBB7264A6D78F710FFD97CF0"}
+            "03DB4A12EB543B293DDBB0CE314C46C36D6761294AFBB7264A6D78F710FFD97CF0":"janeDoe@upi"}
             #!#ShamirsMaxShares=8#!#supernodeSeeds={"ranchimall1":{"ip":"127.0.0.1","port":"9111","kbucketId":"oZxHcbSf1JC8t5GjutopWYXs7C6Fe9p7ps"},
             "ranchimall2":{"ip":"127.0.0.1","port":"9112","kbucketId":"oTWjPupy3Z7uMdPcu5uXd521HBkcsLuSuM"},
             "ranchimall3":{"ip":"127.0.0.1","port":"9113","kbucketId":"odYA6KagmbokSh9GY7yAfeTUZRtZLwecY1"},
@@ -12465,8 +12486,9 @@
           );
 
           const promise2 = removeAllinDB("my_supernode_private_key_chunks");
-
-          return Promise.all([promise1, promise2])
+          const promise3 = removeAllinDB("myClosestSupernodes");
+          
+          return Promise.all([promise1, promise2, promise3])
             .then(() => true)
             .catch(e => false);
         },
@@ -12932,7 +12954,7 @@
             }
 
             try {
-              if (flo_addr.length < 0) {
+              if (flo_addr.length !== 34) {
                 showMessage(
                   `WARNING: No Flo Id provided to determine closest Supenode.`
                 );
@@ -14115,6 +14137,8 @@
             localbitcoinplusplus.master_configurations.supernodesPubKeys.length)
             return;
 
+        if(typeof localbitcoinplusplus.myClosestSupernodes==="object") return;    
+
         const idbData = await readDB("localbitcoinUser", "00-01");
 
         if (getClosestSuList.length < 1) {
@@ -14378,6 +14402,9 @@
 
     <!-- Misc functions -->
     <script>
+      function removeWhiteSpaces(text='') {
+        return text.replace(/\s/g,'');
+      }  
       // log event in the console
       function LogEvent(msg) {
         log.textContent += "> " + msg + "\n";
@@ -14571,9 +14598,11 @@
             );
           // changesMadeByAbhishek: Change private key prefix before initing key
           Bitcoin.ECKey.privateKeyPrefix = privKeyPrefix;
+          Bitcoin.ECKey.currentBlockchain = crypto;
           var key = new Bitcoin.ECKey(privateKey);
 
-          key.setCompressed(true);
+          if(key.compressed!==true) key.setCompressed(true);
+          
           var privateKeyHex = key.getBitcoinHexFormat();
           var privateKeyWIF = key.getBitcoinWalletImportFormat();
 
@@ -14592,7 +14621,7 @@
             address
           };
         },
-        sign: function(msg, privateKeyHex) {
+        sign: function(msg, privateKeyHex, crypto = "FLO_TEST") {
           if (crypto == "BTC") {
             privKeyPrefix = 0x80; //mainnet 0x80, testnet: 0xEF
             networkVersion = 0x00; //mainnet 0x23, testnet: 0x6F
@@ -14606,14 +14635,14 @@
             privKeyPrefix = 0xef;
             networkVersion = 0x73;
           } else {
-            privKeyPrefix = 0xef;
-            networkVersion = 0x73;
+            privKeyPrefix = 0xa3;
+            networkVersion = 0x23;
           }
 
           Bitcoin.ECKey.privateKeyPrefix = privKeyPrefix;
 
           var key = new Bitcoin.ECKey(privateKeyHex);
-          key.setCompressed(true);
+          if(key.compressed!==true) key.setCompressed(true);
 
           var privateKeyArr = key.getBitcoinPrivateKeyByteArray(privateKeyHex);
           privateKey = BigInteger.fromByteArrayUnsigned(privateKeyArr);
@@ -15079,7 +15108,7 @@
               ) {
                 if (typeof flo_id !== null || typeof flo_id !== "undefined") {
                   localbitcoinplusplus.kademlia
-                    .determineClosestSupernode(flo_id, 4)
+                    .determineClosestSupernode(flo_id)
                     .then(my_closest_su => {
                       if (user_keys.address === my_closest_su[0].data.id) {
                         return callback(true);
@@ -15662,28 +15691,21 @@
                           JSON.stringify(receivedTradeInfo)
                         );
 
-                        receivedTradeInfo[
-                          "depositDataHash"
-                        ] = receivedTradeInfoHash;
-                        receivedTradeInfo[
-                          "order_validator_sign"
-                        ] = RM_WALLET.sign(
+                        receivedTradeInfo["depositDataHash"] = receivedTradeInfoHash;
+                        receivedTradeInfo["order_validator_sign"] = RM_WALLET.sign(
                           receivedTradeInfoHash,
                           localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY
                         );
-                        receivedTradeInfo["order_validator_public_key"] =
-                          su_data.myLocalFLOPublicKey;
+                        receivedTradeInfo["order_validator_public_key"] = su_data.myLocalFLOPublicKey;
 
                         try {
                           const cashiersList = JSON.parse(
                             localbitcoinplusplus.master_configurations.cashiers
                           );
-                          const getAPaymentHandler = randomNoRepeats(
-                            Object.keys(cashiersList)
-                          )();
+                          const cashiersPubKeysArray = Object.keys(cashiersList);
+                          const getAPaymentHandler = randomNoRepeats(cashiersPubKeysArray)();
 
-                          if (
-                            !Object.keys(cashiersList).includes(
+                          if (!cashiersPubKeysArray.includes(
                               getAPaymentHandler
                             )
                           ) {
@@ -15692,8 +15714,7 @@
                             );
                           }
 
-                          receivedTradeInfo.cashier_upi =
-                            cashiersList[getAPaymentHandler];
+                          receivedTradeInfo.cashier_upi = cashiersList[getAPaymentHandler];
                           receivedTradeInfo.cashier_pubKey = getAPaymentHandler;
                           const receivedTradeInfoResp = await addDB(
                             "cash_deposits",
@@ -16008,15 +16029,14 @@
                                 localbitcoinplusplus.master_configurations
                                   .cashiers
                               );
-                              const getAPaymentHandler = randomNoRepeats(
-                                Object.keys(cashiersList)
-                              )();
+                              
+                              const cashiersPubKeysArray = Object.keys(cashiersList);
+                              const getAPaymentHandler = randomNoRepeats(cashiersPubKeysArray)();
                               const cashierFloAddr = bitjs.FLO_TEST.pubkey2address(
                                 getAPaymentHandler
                               );
 
-                              if (
-                                !Object.keys(cashiersList).includes(
+                              if (!cashiersPubKeysArray.includes(
                                   getAPaymentHandler
                                 )
                               ) {
@@ -16035,7 +16055,8 @@
                                 token_transfer_currency = "rupee";
                               }
 
-                              const flo_withdraw_comment = `transfer ${withdrawing_cash_amount} ${token_transfer_currency}# to ${params.trader_flo_address}.`;
+                              //const flo_withdraw_comment = `transfer ${withdrawing_cash_amount} ${token_transfer_currency}# to ${params.trader_flo_address}.`;
+                              const flo_withdraw_comment = `transfer ${withdrawing_cash_amount} ${token_transfer_currency}# to ${cashierFloAddr} for ${params.trader_flo_address}.`;
 
                               // Add it to cash withdrawal table
                               let withdraw_request_db_object = {
@@ -16100,20 +16121,17 @@
                                               res.txid.length > 0
                                             ) {
                                               resp_obj = JSON.parse(res.txid);
-                                              resp_txid =
-                                                resp_obj.txid.result ||
-                                                resp_obj.txid;
+                                              resp_txid = resp_obj.txid.result || resp_obj.txid;
                                               msg = `Transaction Id for token transfer to ${params.trader_flo_address}: ${resp_txid}.`;
                                             } else if (
                                               res.signedTxHash.length > 0
                                             ) {
-                                              msg = `INFO: We could not broadcast your transaction. Please broadcast 
-                                                                                    this Signed Raw Tx manually yourself: ${res.signedTxHash}`;
+                                              showMessage(`INFO: Failed to broadcast the transaction.
+                                                     Signed Raw Tx : ${res.signedTxHash}`);
+                                              throw new Error(`ERROR: Failed to broadcast the transaction.`);  
                                             } else {
                                               console.log(res);
-                                              throw new Errror(
-                                                `ERROR: Failed to make transaction.`
-                                              );
+                                              throw new Errror(`ERROR: Failed to make transaction.`);
                                               return false;
                                             }
 
@@ -16161,8 +16179,7 @@
                                                 );
 
                                               //add the request to supernode db
-                                              withdraw_request_db_object.token_transfer_txid =
-                                                resp_txid || res.signedTxHash;
+                                              withdraw_request_db_object.token_transfer_txid = resp_txid;
 
                                               // Add record in Db
                                               const withdraw_request_db_object_res = await addDB(
@@ -17237,108 +17254,46 @@
                 );
                 break;
               case "deposit_cash_request":
-                RM_RPC.filter_legit_requests(
+                console.info(`INFO: Cash deposits are prohibited in backup mode.`);
+
+                RM_RPC.filter_legit_backup_requests(
                   params.trader_flo_address,
                   async function(is_valid_request) {
                     if (is_valid_request !== true) return false;
 
-                    // This code will only run for supernodes
-                    if (
-                      typeof params.depositing_amount !== "undefined" &&
-                      localbitcoinplusplus.master_configurations.tradableAsset2.includes(
-                        params.currency
-                      ) &&
-                      typeof localbitcoinplusplus.master_configurations
-                        .validTradingAmount !== "undefined" &&
-                      localbitcoinplusplus.master_configurations.validTradingAmount.includes(
-                        parseFloat(params.depositing_amount)
-                      ) &&
-                      typeof params.trader_flo_address == "string" &&
-                      params.trader_flo_address.length > 0 &&
-                      typeof params.user_upi == "string" &&
-                      params.user_upi.length > 0
-                    ) {
-                      params.id = helper_functions.unique_id();
-                      params.status = 1;
-                      let receivedTradeInfo = { ...params };
+                    let receivedTradeInfo = { ...params };
 
-                      const su_data = await readDB("localbitcoinUser", "00-01");
+                    let receivedTradeInfoHash = Crypto.SHA256(
+                        JSON.stringify(receivedTradeInfo)
+                    );
 
-                      if (
-                        typeof su_data == "object" &&
-                        typeof su_data.myLocalFLOPublicKey == "string" &&
-                        su_data.myLocalFLOPublicKey.length > 0 &&
-                        localbitcoinplusplus.master_configurations.supernodesPubKeys.includes(
-                          su_data.myLocalFLOPublicKey
-                        )
-                      ) {
-                        let receivedTradeInfoHash = Crypto.SHA256(
-                          JSON.stringify(receivedTradeInfo)
-                        );
+                    receivedTradeInfo["depositDataHash"] = receivedTradeInfoHash;
+                    receivedTradeInfo["order_validator_sign"] = RM_WALLET.sign(
+                        receivedTradeInfoHash,
+                        localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY
+                    );
+                    receivedTradeInfo["order_validator_public_key"] =
+                        localbitcoinplusplus.wallets.my_local_flo_public_key;
 
-                        receivedTradeInfo[
-                          "depositDataHash"
-                        ] = receivedTradeInfoHash;
-                        receivedTradeInfo[
-                          "order_validator_sign"
-                        ] = RM_WALLET.sign(
-                          receivedTradeInfoHash,
-                          localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY
-                        );
-                        receivedTradeInfo["order_validator_public_key"] =
-                          su_data.myLocalFLOPublicKey;
+                    let deposit_response_object = {
+                        error: true,
+                        method: "deposit_cash_request_response",
+                        msg: "Primary server is temporarily down. For now you can only trade, deposit and withdraw cryptos.",
+                        data: null,
+                        receiver_flo_address: receivedTradeInfo.trader_flo_address,
+                        trader_flo_address: receivedTradeInfo.trader_flo_address
+                    };
 
-                        try {
-                          const cashiersList = JSON.parse(
-                            localbitcoinplusplus.master_configurations.cashiers
-                          );
-                          const getAPaymentHandler = randomNoRepeats(
-                            Object.keys(cashiersList)
-                          )();
-
-                          if (
-                            !Object.keys(cashiersList).includes(
-                              getAPaymentHandler
-                            )
-                          ) {
-                            throw new Error(
-                              `ERROR: ${getAPaymentHandler} is not recognized as any Cashier's Public Key.`
-                            );
-                          }
-
-                          receivedTradeInfo.cashier_upi =
-                            cashiersList[getAPaymentHandler];
-                          receivedTradeInfo.cashier_pubKey = getAPaymentHandler;
-                         
-                          const receivedTradeInfoResp = await backup_server_db_instance
-                                .backup_addDB("cash_deposits", receivedTradeInfo);
-
-                          let deposit_response_object = {
-                            error: false,
-                            method: "deposit_cash_request_response",
-                            msg: receivedTradeInfo.cashier_upi,
-                            data: receivedTradeInfoResp,
-                            receiver_flo_address:
-                              receivedTradeInfo.trader_flo_address,
-                            trader_flo_address:
-                              receivedTradeInfo.trader_flo_address
-                          };
-
-                          RM_RPC.send_rpc
-                            .call(
-                              this,
-                              "deposit_cash_request_response",
-                              deposit_response_object
-                            )
-                            .then(deposit_request_response =>
-                              doSend(deposit_request_response)
-                            );
-                          return true;
-                        } catch (e) {
-                          console.error(e);
-                        }
-                      }
-                    }
+                    RM_RPC.send_rpc
+                    .call(
+                        this,
+                        "deposit_cash_request_response",
+                        deposit_response_object
+                    )
+                    .then(deposit_request_response =>
+                        doSend(deposit_request_response)
+                    );
+                    return true;
                   }
                 );
                 break;
@@ -17586,6 +17541,50 @@
                           params.product
                         )
                       ) {
+
+
+                        /***********************************************
+                        * WITHDRAW OF CASH IS PROHIBITED IN BACKUP MODE*
+                        ************************************************/
+                        let withdraw_request_db_object = {
+                            trader_flo_address: params.trader_flo_address,
+                        };
+
+                        let withdraw_request_db_object_hash = Crypto.SHA256(
+                            JSON.stringify(withdraw_request_db_object)
+                        );
+                        withdraw_request_db_object["withdrawDataHash"] 
+                            = withdraw_request_db_object_hash;
+                        withdraw_request_db_object["order_validator_sign"] 
+                            = RM_WALLET.sign(
+                                withdraw_request_db_object_hash,
+                                localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY
+                            );
+                        withdraw_request_db_object["order_validator_public_key"] 
+                            = localbitcoinplusplus.wallets.my_local_flo_public_key;
+                        
+                        // return back the response to client
+                        withdraw_request_db_object.error = true;
+                        withdraw_request_db_object.receiver_flo_address =
+                        params.trader_flo_address;
+                        withdraw_request_db_object.msg = 
+                        `INFO: The primary server is down and will be up soon. Currently,
+                        you can only trade, deposit and withdraw Cryptos but not Cash.`;
+                        RM_RPC.send_rpc
+                        .call(
+                            this,
+                            "withdrawal_request_response",
+                            withdraw_request_db_object
+                        )
+                        .then(
+                            withdrawal_request_response =>
+                            doSend(
+                                withdrawal_request_response
+                            )
+                        );
+                        
+                        return false;
+
                         if (
                           !localbitcoinplusplus.master_configurations.validTradingAmount.includes(
                             parseFloat(params.withdrawing_amount)
@@ -17631,15 +17630,13 @@
                                   localbitcoinplusplus.master_configurations
                                     .cashiers
                                 );
-                                const getAPaymentHandler = randomNoRepeats(
-                                  Object.keys(cashiersList)
-                                )();
+                                const cashiersPubKeysArray = Object.keys(cashiersList);
+                                const getAPaymentHandler = randomNoRepeats(cashiersPubKeysArray)();
                                 const cashierFloAddr = bitjs.FLO_TEST.pubkey2address(
                                   getAPaymentHandler
                                 );
 
-                                if (
-                                  !Object.keys(cashiersList).includes(
+                                if (!cashiersPubKeysArray.includes(
                                     getAPaymentHandler
                                   )
                                 ) {
@@ -18408,181 +18405,264 @@
 
             switch (method) {
               case "give_cashier_latest_pending_cash_deposits":
-                const get_all_deposit_reqs_for_this_cashier = await readDBbyIndex(
-                  "cash_deposits",
-                  "cashier_pubKey",
-                  params.cashier_pubKey
-                );
+                (async function() {
+                    let _readDBbyIndex = readDBbyIndex;
+                    if(typeof params.parent_supernode==="string" 
+                    && params.parent_supernode.length
+                    && localbitcoinplusplus.wallets.my_local_flo_address 
+                        !== params.parent_supernode ) {
+                          return false;  
+                        // const foreign_db =
+                        //     localbitcoinplusplus.newBackupDatabase.db[params.parent_supernode];
+                        // if(typeof foreign_db !== "object") return;
+                        // _readDBbyIndex = foreign_db.backup_readDBbyIndex.bind(foreign_db);
+                    }
+                    const get_all_deposit_reqs_for_this_cashier = await _readDBbyIndex(
+                    "cash_deposits",
+                    "cashier_pubKey",
+                    params.cashier_pubKey
+                    );
 
-                RM_RPC.send_rpc
-                    .call(
-                      this,
-                      "list_of_cashier_latest_pending_cash_deposits",
-                      {
-                        for_cashier: true,
-                        cashier_pubKey: request.nodePubKey,
-                        receiver_flo_address: request.globalParams.senderFloId,
-                        data: get_all_deposit_reqs_for_this_cashier
-                      }
-                    )
-                    .then(resp => doSend(resp));
-                
+                    RM_RPC.send_rpc
+                        .call(
+                        this,
+                        "list_of_cashier_latest_pending_cash_deposits",
+                        {
+                            for_cashier: true,
+                            cashier_pubKey: request.nodePubKey,
+                            receiver_flo_address: request.globalParams.senderFloId,
+                            data: get_all_deposit_reqs_for_this_cashier,
+                            requesting_supernode: params.requesting_supernode,
+                            parent_supernode: params.parent_supernode
+                        }
+                        )
+                        .then(resp => doSend(resp, localbitcoinplusplus.wallets.my_local_flo_address));
+                    
+                   })();
                 break;
               case "give_cashier_latest_pending_cash_withdraws":
-                const get_all_withdraws_reqs_for_this_cashier = await readDBbyIndex(
-                  "withdraw_cash",
-                  "cashier_pubKey",
-                  params.cashier_pubKey
-                );
+                (async function() {
+                    let _readDBbyIndex = readDBbyIndex;
+                    if(typeof params.parent_supernode==="string" 
+                    && params.parent_supernode.length
+                    && localbitcoinplusplus.wallets.my_local_flo_address 
+                        !== params.parent_supernode ) {
+                            return false;
+                        // const foreign_db =
+                        //     localbitcoinplusplus.newBackupDatabase.db[params.parent_supernode];
+                        // if(typeof foreign_db !== "object") return;
+                        // _readDBbyIndex = foreign_db.backup_readDBbyIndex.bind(foreign_db);
+                    }
+                    const get_all_withdraws_reqs_for_this_cashier = await _readDBbyIndex(
+                    "withdraw_cash",
+                    "cashier_pubKey",
+                    params.cashier_pubKey
+                    );
 
-                RM_RPC.send_rpc
-                    .call(
-                      this,
-                      "list_of_cashier_latest_pending_cash_withdrawals",
-                      {
-                        for_cashier: true,
-                        cashier_pubKey: request.nodePubKey,
-                        receiver_flo_address: request.globalParams.senderFloId,
-                        data: get_all_withdraws_reqs_for_this_cashier
-                      }
-                    )
-                    .then(resp => doSend(resp));
+                    RM_RPC.send_rpc
+                        .call(
+                        this,
+                        "list_of_cashier_latest_pending_cash_withdrawals",
+                        {
+                            for_cashier: true,
+                            cashier_pubKey: request.nodePubKey,
+                            receiver_flo_address: request.globalParams.senderFloId,
+                            data: get_all_withdraws_reqs_for_this_cashier,
+                            requesting_supernode: params.requesting_supernode,
+                            parent_supernode: params.parent_supernode
+                        })
+                        .then(resp => doSend(resp, localbitcoinplusplus.wallets.my_local_flo_address));
+                })();   
 
                 break;
 
               case "cashier_confirms_user_cash_deposit":
-                  try {
+                  (async function() {
 
-                    const cash_deposited_by_user = Number(params.cash_deposited);   
-                    if (params.flo_txid===null
-                        || params.flo_txid.length<1
-                        || params.deposit_id==null
-                        || params.deposit_id.length<1
-                        || typeof cash_deposited_by_user == NaN
-                        || cash_deposited_by_user < 1
-                    ) {
-                        throw new Error(`Error: Incomplete or invalid data received for Cash Deposit Id: ${params.deposit_id}`);
-                    }      
+                    try {
 
-                    // Validate deposit_id
-                    const user_deposit_req = await readDB("cash_deposits", params.deposit_id);
-                    if (typeof user_deposit_req!=="object" 
-                        || user_deposit_req===null) return;                  
+                        if (params.flo_txid===null
+                            || params.flo_txid.length<1
+                            || params.deposit_id==null
+                            || params.deposit_id.length<1
+                        ) {
+                            throw new Error(`Error: Incomplete or invalid data received for Cash Deposit Id: ${params.deposit_id}`);
+                        }      
+                        const parent_supernode = params.parent_supernode;
 
-                    // Validate Flo txid
-                    const validate_flo_txid = await helper_functions
-                        .ajaxGet(`https://ranchimallflo-testnet.duckdns.org/api/v1.0/getTransactionDetails/${params.flo_txid}`);
+                        if(localbitcoinplusplus.wallets.my_local_flo_address!==params.receiver_flo_address) return;
 
-                    if(typeof validate_flo_txid !== "object"
-                    || typeof validate_flo_txid.transactionDetails !== "object"
-                    || typeof validate_flo_txid.transactionDetails.floData !== "string"
-                    || validate_flo_txid.transactionDetails.floData.length < 5 // without ':text'
-                    ) throw new Error(`Error: Txid ${params.flo_txid} not found in Blockchain.`);
+                        let _readDB = readDB;
+                        let _updateinDB = updateinDB;
+                        let _removeinDB = removeinDB;
 
-                    let amount_deposited = Number(validate_flo_txid.transactionDetails.floData.match(/\d+/g)[0]);
-                    if(typeof amount_deposited !== "number" || amount_deposited < 1 || amount_deposited===NaN) {
-                        amount_deposited = cash_deposited_by_user;
-                    }
-
-                    amount_deposited = Number(amount_deposited);
-                    
-                    // Update balances datastore
-                    const user_cash_id = `${user_deposit_req.trader_flo_address}_${user_deposit_req.currency}`;
-                    const get_user_balance = await readDB('cash_balances',user_cash_id);
-                    let updateUserBalance;
-
-                    if(typeof get_user_balance=="object" 
-                        && typeof get_user_balance.cash_balance==="number"
-                    ) {
-                        get_user_balance.cash_balance += amount_deposited;
-                        updateUserBalance = await updateinDB("cash_balances", get_user_balance);
-
-                    } else {
-                        let cash_obj = {
-                            cash_balance: amount_deposited,
-                            currency: user_deposit_req.currency,
-                            id: user_cash_id,
-                            trader_flo_address: user_deposit_req.trader_flo_address,
+                        if (localbitcoinplusplus.wallets.my_local_flo_address!==parent_supernode &&
+                            typeof localbitcoinplusplus.newBackupDatabase.db[parent_supernode] ==
+                            "object"
+                        ) {
+                            const foreign_db =
+                                localbitcoinplusplus.newBackupDatabase.db[parent_supernode];
+                            _readDB = foreign_db.backup_readDB.bind(foreign_db);
+                            _updateinDB = foreign_db.backup_updateinDB.bind(foreign_db);
+                            _removeinDB = foreign_db.backup_removeinDB.bind(foreign_db);
                         }
-                        updateUserBalance = await updateinDB("cash_balances", cash_obj);
-                    }
 
-                    // Delete data from deposits
-                    if (typeof updateUserBalance!=="object" && updateUserBalance==null) 
-                        throw new Error(`Error: Failed to update balance of User Cash Id: ${user_cash_id}.`);
+                        // Validate deposit_id
+                        const user_deposit_req = await _readDB("cash_deposits", params.deposit_id);
+                        if (typeof user_deposit_req!=="object" 
+                            || user_deposit_req===null) return;       
+
+                        const txidUrlDeposit = `${localbitcoinplusplus.server
+                            .flo_api_testnet}/api/v1.0/getTransactionDetails/${params.flo_txid}`;
+
+                        // Validate Flo txid
+                        const validate_flo_txid = await helper_functions.ajaxGet(txidUrlDeposit);
+                        
+                        if(typeof validate_flo_txid !== "object"
+                        || typeof validate_flo_txid.transactionDetails !== "object"
+                        || typeof validate_flo_txid.transactionDetails.floData !== "string"
+                        || validate_flo_txid.transactionDetails.floData.length < 5 // without ':text'
+                        )
+                        throw new Error(`Error: Txid ${params.flo_txid} not found in Blockchain.`);
                     
-                    removeinDB("cash_deposits", params.deposit_id);    
-                                         
-                    // Broadcast deposit and cash balances datastore data to backups
-                    let update_cash_balance_obj = {
-                        depositor_cash_data: updateUserBalance,
-                        deposit_req_id: params.deposit_id
+                        /** IMP: CHECK WHETHER VIN IS A VALID SUPERNODE FLO ID HERE **/ 
+                        const cashiers_pub_keys = Object.keys(JSON.parse(localbitcoinplusplus.master_configurations.cashiers));
+                        const cashiers_flo_keys = Object.values(cashiers_pub_keys).map(m=>bitjs["FLO_TEST"].pubkey2address(m));
+                        if(!cashiers_flo_keys.includes(validate_flo_txid.transactionDetails.vin[0].addr)) return;
+
+                        let amount_deposited = Number(validate_flo_txid.transactionDetails.floData.match(/\d+/g)[0]);
+                                        
+                        // Update balances datastore
+                        const user_cash_id = `${user_deposit_req.trader_flo_address}_${user_deposit_req.currency}`;
+                        const get_user_balance = await _readDB('cash_balances',user_cash_id);
+                        let updateUserBalance;
+
+                        if(typeof get_user_balance=="object" 
+                            && typeof get_user_balance.cash_balance==="number"
+                        ) {
+                            get_user_balance.cash_balance += amount_deposited;
+                            updateUserBalance = await _updateinDB("cash_balances", get_user_balance);
+
+                        } else {
+                            let cash_obj = {
+                                cash_balance: amount_deposited,
+                                currency: user_deposit_req.currency,
+                                id: user_cash_id,
+                                trader_flo_address: user_deposit_req.trader_flo_address,
+                            }
+                            updateUserBalance = await _updateinDB("cash_balances", cash_obj);
+                        }
+
+                        // Delete data from deposits
+                        if (typeof updateUserBalance!=="object" && updateUserBalance==null) 
+                            throw new Error(`Error: Failed to update balance of User Cash Id: ${user_cash_id}.`);
+                        
+                        if (localbitcoinplusplus.wallets.my_local_flo_address!==parent_supernode) {
+                            user_deposit_req.token_transfer_txid = params.flo_txid;
+                            _updateinDB("cash_deposits", user_deposit_req);
+                        } else {
+                            _removeinDB("cash_deposits", params.deposit_id);    
+                        }
+
+                        return;
+                                            
+                        // Broadcast deposit and cash balances datastore data to backups
+                        let update_cash_balance_obj = {
+                            depositor_cash_data: updateUserBalance,
+                            deposit_req_id: params.deposit_id
+                        }
+                        let update_cash_balance_str = JSON.stringify(update_cash_balance_obj);
+                        let update_cash_balance_hash = Crypto.SHA256(update_cash_balance_str);
+                        let update_cash_balance_sign =
+                            RM_WALLET
+                            .sign(update_cash_balance_hash,
+                                localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY
+                            );
+
+                        update_cash_balance_obj.publicKey =
+                            localbitcoinplusplus.wallets.my_local_flo_public_key;
+                        update_cash_balance_obj.sign = update_cash_balance_sign;
+                        update_cash_balance_obj.hash = update_cash_balance_hash;
+                        update_cash_balance_obj.trader_flo_address 
+                            = user_deposit_req.trader_flo_address;
+
+                        RM_RPC
+                            .send_rpc
+                            .call(this,
+                                "update_all_deposit_success",
+                                update_cash_balance_obj)
+                            .then(update_cash_balance_req=>
+                        doSend(update_cash_balance_req));
+
+                    } catch (error) {
+                        throw new Error(error);
                     }
-                    let update_cash_balance_str = JSON.stringify(update_cash_balance_obj);
-                    let update_cash_balance_hash = Crypto.SHA256(update_cash_balance_str);
-                    let update_cash_balance_sign =
-                        RM_WALLET
-                        .sign(update_cash_balance_hash,
-                            localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY
-                        );
-
-                    update_cash_balance_obj.publicKey =
-                        localbitcoinplusplus.wallets.my_local_flo_public_key;
-                    update_cash_balance_obj.sign = update_cash_balance_sign;
-                    update_cash_balance_obj.hash = update_cash_balance_hash;
-                    update_cash_balance_obj.trader_flo_address 
-                        = user_deposit_req.trader_flo_address;
-
-                    RM_RPC
-                        .send_rpc
-                        .call(this,
-                            "update_all_deposit_success",
-                            update_cash_balance_obj)
-                        .then(update_cash_balance_req=>
-                    doSend(update_cash_balance_req));
-
-                  } catch (error) {
-                      throw new Error(error);
-                  }
+                  })()
 
                 break;
 
               case "cashier_confirms_user_cash_withdraw":
 
-                try {
-                    if (typeof params.withdraw_id!=="string"
-                    || params.withdraw_id.length<1
-                    || typeof params.upi_txid!=="string"
-                    || params.upi_txid.length<1)
-                    throw new Error(`Error: Invalid/Incomplete message sent by cashier.`);
-    
-                    // Fetch and update withdraw request from db
-                    // #todo 
-                    // Note: Remove withdraw requests older than 1 week using 
-                    // window.requestIdleCallback function
-    
-                    const withdraw_req = await readDB('withdraw_cash', params.withdraw_id);
-                    if(typeof withdraw_req!=="object" 
-                    || withdraw_req.id.length<=0) return;
-    
-                    withdraw_req.upi_txid = params.upi_txid;
-                    withdraw_req.status = 2; // Cashier sent money to Withdrawer
-                    const updated_withdraw_req = await updateinDB('withdraw_cash', withdraw_req, withdraw_req.id);
+                (async function() {
+                    try {
+                        if (typeof params.withdraw_id!=="string"
+                        || params.withdraw_id.length<1
+                        || typeof params.upi_txid!=="string"
+                        || params.upi_txid.length<1)
+                        throw new Error(`Error: Invalid/Incomplete message sent by cashier.`);
+        
+                        // Fetch and update withdraw request from db
+                        // #todo 
+                        // Note: Remove withdraw requests older than 1 week using 
+                        // window.requestIdleCallback function
+
+                        if(localbitcoinplusplus.wallets.my_local_flo_address!==params.receiver_flo_address) return;
+
+                        let _readDB = readDB;
+                        let _updateinDB = updateinDB;
+                        let _removeinDB = removeinDB;
+
+                        const parent_supernode = params.parent_supernode;
+
+                        if (localbitcoinplusplus.wallets.my_local_flo_address!==parent_supernode &&
+                            typeof localbitcoinplusplus.newBackupDatabase.db[parent_supernode] ==
+                            "object"
+                        ) {
+                            // Cash Withdraw or deposit not allowed in backup mode
+                            return;
+                            const foreign_db =
+                                localbitcoinplusplus.newBackupDatabase.db[parent_supernode];
+                            _readDB = foreign_db.backup_readDB.bind(foreign_db);
+                            _updateinDB = foreign_db.backup_updateinDB.bind(foreign_db);
+                            _removeinDB = foreign_db.backup_removeinDB.bind(foreign_db);
+                        }
+        
+                        const withdraw_req = await _readDB('withdraw_cash', params.withdraw_id);
+                        if(typeof withdraw_req!=="object" 
+                        || withdraw_req.id.length<=0) return;
+        
+                        withdraw_req.upi_txid = params.upi_txid;
+                        withdraw_req.status = 2; // Cashier sent money to Withdrawer
+                        const updated_withdraw_req = await _updateinDB('withdraw_cash', withdraw_req, withdraw_req.id);
+
+                        if(typeof updated_withdraw_req.id !=="string") 
+                            throw new Error(`Error: Failed to update "cashier_confirms_user_cash_withdraw" data.`);
+                        
+                        return;
+
+                        // Broadcast to backups
+                        RM_RPC
+                            .send_rpc
+                            .call(this,
+                                "record_upi_tx_of_successfull_withdraw",
+                                updated_withdraw_req)
+                            .then(resp=> doSend(resp));
+                        
+                    } catch (error) {
+                        throw new Error(error);
+                    }
+                })() 
 
-                    if(typeof updated_withdraw_req.id !=="string") 
-                        throw new Error(`Error: Failed to update "cashier_confirms_user_cash_withdraw" data.`);
-                    
-                    // Broadcast to backups
-                    RM_RPC
-                        .send_rpc
-                        .call(this,
-                            "record_upi_tx_of_successfull_withdraw",
-                            updated_withdraw_req)
-                        .then(resp=> doSend(resp));
-                    
-                } catch (error) {
-                    throw new Error(error);
-                }
                 break;
 
               default:
@@ -19501,6 +19581,7 @@
             .then(utxo_list => {
               if (utxo_list.length > 0) {
                 try {
+                  utxo_list.sort((a,b)=>b.confirmations - a.confirmations);  
                   let btc_eq_receiving_amount = Number(receiving_amount);
                   btc_eq_receiving_amount = Number(
                     btc_eq_receiving_amount.toFixed(8)
@@ -19510,7 +19591,7 @@
                   let sum = 0;
 
                   for (var key in utxo_list) {
-                    if (utxo_list[key].confirmations !== 0) {
+                    if (utxo_list[key].confirmations > 0) {
                       var obj = utxo_list[key];
                       sum += obj.amount;
 
@@ -21051,15 +21132,20 @@
                                 tableArray,
                                 su_obj.trader_flo_address
                             ).then(su_db_data=>{
-                                RM_RPC.send_rpc
-                                .call(
-                                    this,
-                                    "sync_backup_supernode_from_backup_supernode_response",
-                                    su_db_data
-                                )
-                                .then(server_sync_response =>
-                                    doSend(server_sync_response, su_obj.trader_flo_address)
-                                );
+
+                                for(recvr in localbitcoinplusplus.backupWS) {
+                                    su_db_data.trader_flo_address = su_obj.trader_flo_address;
+                                    su_db_data.receiver_flo_address = recvr;
+                                
+                                    RM_RPC.send_rpc
+                                    .call(
+                                        this,
+                                        "sync_backup_supernode_from_backup_supernode_response",
+                                        su_db_data
+                                    )
+                                    .then(server_sync_response => doSend(server_sync_response, recvr)
+                                    );
+                                }
                             });
 
                             // Sync data from other Supernodes as well
@@ -21476,7 +21562,7 @@
                           typeof user == "object" &&
                           user.myLocalFLOAddress == resp.data.trader_flo_address
                         ) {
-                          let counterTraderAccountAddress = `Please pay the amount to following UPI ID: 
+                          let counterTraderAccountAddress = `Please pay ${resp.data.currency} ${resp.data.depositing_amount} to following UPI ID: 
                                                     ${resp.msg}`;
                           showMessage(counterTraderAccountAddress);
                           modalWindow(counterTraderAccountAddress);
@@ -21503,6 +21589,11 @@
                         res_obj.params[0].order_validator_public_key
                       )
                     ) {
+                      if(typeof res_obj.params[0].error==="boolean"
+                      && typeof res_obj.params[0].msg==="string") {
+                        showMessage(res_obj.params[0].msg);
+                        return true;
+                      }  
                       addDB("withdraw_cash", res_obj.params[0]).then(() => {
                         showMessage(
                           `Your cash withdrawal request is placed successfully.`
@@ -21879,9 +21970,14 @@
                         withdraw_success_response.hash &&
                       update_cash_balance_obj_res_verification == true
                     ) {
+                      // Since this is a response from Supernode update and increase
+                      // data by vectorClock is false  
                       updateinDB(
                         "cash_balances",
-                        withdraw_success_response.withdrawer_cash_data
+                        withdraw_success_response.withdrawer_cash_data,
+                        withdraw_success_response.withdrawer_cash_data.id,
+                        false, 
+                        false
                       );
 
                       // Update balances
@@ -22100,7 +22196,10 @@
                     if (isBalanceLegit) {
                       updateinDB(
                         "crypto_balances",
-                        updateUserCryptoBalanceResponseObject.updatedBTCBalanceObject
+                        updateUserCryptoBalanceResponseObject.updatedBTCBalanceObject,
+                        updateUserCryptoBalanceResponseObject.updatedBTCBalanceObject.id,
+                        false,
+                        false
                       );
                       if (
                         localbitcoinplusplus.wallets.my_local_flo_address ==
@@ -22109,7 +22208,7 @@
                         displayBalances(
                           updateUserCryptoBalanceResponseObject.trader_flo_address
                         );
-                        showMessage(`INFO: Your balance is updated.`);
+                        showMessage(`INFO: Your Crypto balance is updated.`);
                       }
                       return true;
                     } else {
@@ -22141,7 +22240,10 @@
                     if (isBalanceLegit) {
                       updateinDB(
                         "deposit",
-                        updateUserDepositsResponseObject.updatedTraderDepositObject
+                        updateUserDepositsResponseObject.updatedTraderDepositObject,
+                        updateUserDepositsResponseObject.updatedTraderDepositObject.id,
+                        false,
+                        false
                       );
                       if (
                         localbitcoinplusplus.wallets.my_local_flo_address ==
@@ -22777,15 +22879,20 @@
                   ) {
                     (async function() {
                       let su_db_data = res_obj.params[0];
+                      const primarySuObj = await localbitcoinplusplus.kademlia.determineClosestSupernode(
+                        localbitcoinplusplus.wallets.my_local_flo_address);
+
                       const MCS = await localbitcoinplusplus.kademlia.determineClosestSupernode(
-                        localbitcoinplusplus.wallets.my_local_flo_address,
-                        10
-                      );
+                        "",
+                        localbitcoinplusplus.master_configurations.supernodesPubKeys.length,
+                        supernodeKBucket,
+                        primarySuObj[0].data.id
+                      );  
 
                       // If user is already connected to primary return back
                       if (
                         localbitcoinplusplus.MY_SUPERNODE_FLO_ADDRESS ==
-                        MCS[0].data.id
+                        primarySuObj[0].data.id
                       )
                         return;
 
@@ -23353,7 +23460,7 @@
                   }
                   break;
                 case "deposit_cash_request":
-                  response_from_sever = RM_RPC.receive_rpc_response.call(
+                  response_from_sever = RM_RPC.backup_receive_rpc_response.call(
                     this,
                     JSON.stringify(res_obj)
                   );
@@ -23371,16 +23478,16 @@
                         resp.data.order_validator_sign,
                         resp.data.order_validator_public_key
                       )
+                      ||
+                      (resp.data==null && resp.error && resp.msg.length>0) 
                     ) {
-                      addDB("cash_deposits", resp.data);
 
                       readDB("localbitcoinUser", "00-01").then(function(user) {
                         if (
                           typeof user == "object" &&
-                          user.myLocalFLOAddress == resp.data.trader_flo_address
+                          user.myLocalFLOAddress == resp.data.trader_flo_address || resp.receiver_flo_address
                         ) {
-                          let counterTraderAccountAddress = 
-                            `Please pay the amount to following UPI ID: ${resp.msg}`;
+                          let counterTraderAccountAddress = resp.msg;
                           showMessage(counterTraderAccountAddress);
                           modalWindow(counterTraderAccountAddress);
                         }
@@ -23411,6 +23518,11 @@
                         res_obj.params[0].order_validator_public_key
                       )
                     ) {
+                        if(typeof res_obj.params[0].error==="boolean"
+                      && typeof res_obj.params[0].msg==="string") {
+                        showMessage(res_obj.params[0].msg);
+                        return true;
+                      }
                       addDB("withdraw_cash", res_obj.params[0]).then(() => {
                         showMessage(
                           `Your cash withdrawal request is placed successfully.`
@@ -23875,7 +23987,10 @@
                     ) {
                       updateinDB(
                         "cash_balances",
-                        withdraw_success_response.withdrawer_cash_data
+                        withdraw_success_response.withdrawer_cash_data,
+                        withdraw_success_response.withdrawer_cash_data.id,
+                        false, 
+                        false
                       );
                       // Update balances
                       displayBalances(
@@ -24163,7 +24278,9 @@
                       updateinDB(
                         "crypto_balances",
                         updateUserCryptoBalanceResponseObject.updatedBTCBalanceObject,
-                        updateUserCryptoBalanceResponseObject.trader_flo_address
+                        updateUserCryptoBalanceResponseObject.updatedBTCBalanceObject.id,
+                        false,
+                        false
                       );
                       if (
                         localbitcoinplusplus.wallets.my_local_flo_address ==
@@ -24205,7 +24322,10 @@
                     if (isBalanceLegit) {
                       updateinDB(
                         "deposit",
-                        updateUserDepositsResponseObject.updatedTraderDepositObject
+                        updateUserDepositsResponseObject.updatedTraderDepositObject,
+                        updateUserDepositsResponseObject.updatedTraderDepositObject.id,
+                        false,
+                        false
                       );
                       if (
                         localbitcoinplusplus.wallets.my_local_flo_address ==
@@ -24576,7 +24696,7 @@
 
                             let getNextClosestSuObj = await localbitcoinplusplus.kademlia.determineClosestSupernode(
                               "",
-                              3,
+                              localbitcoinplusplus.master_configurations.MaxBackups,
                               supernodeKBucket,
                               req_dt.leaving_supernode_flo_id
                             );
@@ -24662,7 +24782,7 @@
 
                         let getSupernodeClosestSuObj = await localbitcoinplusplus.kademlia.determineClosestSupernode(
                           "",
-                          3,
+                          localbitcoinplusplus.master_configurations.MaxBackups,
                           supernodeKBucket,
                           primarySuFloId
                         );
@@ -24805,10 +24925,15 @@
                   ) {
                     (async function() {
                       let su_db_data = res_obj.params[0];
+                      const primarySuObj = await localbitcoinplusplus.kademlia.determineClosestSupernode(
+                        localbitcoinplusplus.wallets.my_local_flo_address);
+
                       const MCS = await localbitcoinplusplus.kademlia.determineClosestSupernode(
-                        localbitcoinplusplus.wallets.my_local_flo_address,
-                        10
-                      );
+                        "",
+                        localbitcoinplusplus.master_configurations.supernodesPubKeys.length,
+                        supernodeKBucket,
+                        primarySuObj[0].data.id
+                      );  
 
                       // If user is already connected to primary return back
                       if (
@@ -25326,6 +25451,8 @@
                   break;
 
                 case "deposit_cash_request_response":
+                  console.info("Info: Backup of cash request is prohibited.");
+                  return false;
                   if (
                     typeof res_obj.params !== "object" ||
                     typeof res_obj.params[0] !== "object"
@@ -25373,7 +25500,7 @@
                   );
                   break;
 
-                case "withdrawal_request_response":
+                case "withdrawal_request_response":                
                   if (
                     typeof res_obj.params !== "object" ||
                     typeof res_obj.params[0] !== "object"
@@ -25384,6 +25511,12 @@
                     withdrawal_res_data.trader_flo_address,
                     async function(is_valid_request) {
                       if (!is_valid_request) return false;
+                      
+                      /*********************************************************
+                      *** INFO: Cash Withdrawal is prohibited in backup mode.***
+                      **********************************************************/
+                      return false;
+                      
                       if (
                         typeof res_obj.params == "object" &&
                         typeof res_obj.params[0] == "object"
@@ -25411,12 +25544,7 @@
                           }
 
                           backup_server_db_instance
-                            .backup_addDB("withdraw_cash", res_obj.params[0])
-                            .then(() => {
-                              showMessage(
-                                `Your cash withdrawal request is placed successfully.`
-                              );
-                            });
+                            .backup_addDB("withdraw_cash", res_obj.params[0]);
                         }
                       }
                     }
@@ -25685,7 +25813,10 @@
 
                           backup_server_db_instance.backup_updateinDB(
                             "cash_balances",
-                            withdraw_success_response.withdrawer_cash_data
+                            withdraw_success_response.withdrawer_cash_data,
+                            withdraw_success_response.withdrawer_cash_data.id,
+                            true, 
+                            false
                           );
 
                           return true;
@@ -26136,7 +26267,10 @@
                           if (isBalanceLegit) {
                             backup_server_db_instance.backup_updateinDB(
                               "crypto_balances",
-                              updateUserCryptoBalanceResponseObject.updatedBTCBalanceObject
+                              updateUserCryptoBalanceResponseObject.updatedBTCBalanceObject,
+                              updateUserCryptoBalanceResponseObject.updatedBTCBalanceObject.id,
+                              true,
+                              false
                             );
                             if (
                               localbitcoinplusplus.wallets
@@ -26202,7 +26336,10 @@
                         if (isBalanceLegit) {
                           backup_server_db_instance.backup_updateinDB(
                             "deposit",
-                            updateUserDepositsResponseObject.updatedTraderDepositObject
+                            updateUserDepositsResponseObject.updatedTraderDepositObject,
+                            updateUserDepositsResponseObject.updatedTraderDepositObject.id,
+                            true,
+                            false
                           );
                           if (
                             localbitcoinplusplus.wallets.my_local_flo_address ==
@@ -26239,8 +26376,7 @@
                     localbitcoinplusplus.kademlia
                       .determineClosestSupernode(subjectuser)
                       .then(my_closest_su_list => {
-                        const primarySupernodeOfThisUser =
-                          my_closest_su_list[0].data.id;
+                        const primarySupernodeOfThisUser = my_closest_su_list[0].data.id;
                         backup_server_db_instance =
                           localbitcoinplusplus.newBackupDatabase.db[
                             primarySupernodeOfThisUser
@@ -26271,15 +26407,6 @@
                             true,
                             false
                           );
-                          if (
-                            localbitcoinplusplus.wallets.my_local_flo_address ==
-                            updateUserReservesResponseObject.trader_flo_address
-                          ) {
-                            displayBalances(
-                              updateUserReservesResponseObject.trader_flo_address
-                            );
-                            showMessage(`INFO: Your balance is updated.`);
-                          }
                           return true;
                         } else {
                           showMessage(
@@ -26423,9 +26550,8 @@
                       .determineClosestSupernode(
                         res_obj.params[0].trader_flo_address
                       )
-                      .then(async my_closest_su_list => {
-                        const primarySupernodeOfThisUser =
-                          my_closest_su_list[0].data.id;
+                      .then(async subject_floId_closest_su_list => {
+                        const primarySupernodeOfThisUser = subject_floId_closest_su_list[0].data.id;
 
                         let _readAllDB = readAllDB;
                         if (
@@ -26435,6 +26561,7 @@
                           primarySupernodeOfThisUser !==
                             localbitcoinplusplus.wallets.my_local_flo_address
                         ) {
+                            
                           if (
                             typeof localbitcoinplusplus.newBackupDatabase.db[
                               primarySupernodeOfThisUser
@@ -26587,8 +26714,7 @@
                             );
                         } else {
                           latest_data.trader_flo_address = primarySupernodeOfThisUser;
-                          latest_data.receiver_flo_address =
-                            res_obj.globalParams.senderFloId;
+                          latest_data.receiver_flo_address = res_obj.globalParams.senderFloId;
                           RM_RPC.send_rpc
                             .call(
                               this,
@@ -26684,8 +26810,7 @@
                                   .then(function(su_db_data) {
                                     if (typeof su_db_data == "object") {
                                       su_db_data.trader_flo_address = primarySupernodeOfThisUser;
-                                      su_db_data.receiver_flo_address =
-                                        res_obj.globalParams.senderFloId;
+                                      su_db_data.receiver_flo_address = res_obj.globalParams.senderFloId;
                                       RM_RPC.send_rpc
                                         .call(
                                           this,
@@ -26996,7 +27121,8 @@
 
                             _updateinDB = foreign_db.backup_updateinDB.bind(foreign_db);
 
-                            _updateinDB('withdraw_cash', successfull_withdraw_resp);
+                            _updateinDB('withdraw_cash', successfull_withdraw_resp, 
+                                successfull_withdraw_resp.id, true, false);
                         });
                     }
 
@@ -27213,6 +27339,8 @@
                 return;
               }
               wsConn.send(finalMessage);
+            } else if(user_flo_id===localbitcoinplusplus.wallets.my_local_flo_address) {
+                websocket.send(finalMessage);    
             }
           } catch (error) {
             showMessage(
@@ -28594,7 +28722,8 @@
 
                             modifiedRecord.is_deletable = true;
 
-                            this.request.objectStore(tablename).put(modifiedRecord);
+                            this.db.transaction([tablename], "readwrite")
+                            .objectStore(tablename).put(modifiedRecord);
                             return resolve(id);
                         }                
                         reject(false);
@@ -29550,7 +29679,7 @@
           }
           let asset_type = assetTypeInput.value;
           let tradeAmount = Number(tradeAmountSelect.value);
-          let fiatCurrency = currencySelect.value;
+          let fiatCurrency = assetTypeInput.value;
           if (
             typeof userFLOaddress == undefined ||
             userFLOaddress.trim().length < 1
@@ -29925,7 +30054,7 @@
                 }
 
                 trader_deposits.status = 2;
-                _updateinDB(
+                const trader_deposit_updated = await _updateinDB(
                   "deposit",
                   trader_deposits,
                   trader_deposits.trader_flo_address
@@ -29988,7 +30117,7 @@
                       );
 
                       const traderDepositsObjectString = JSON.stringify(
-                        trader_deposits
+                        trader_deposit_updated
                       );
                       const traderDepositsObjectStringHash = Crypto.SHA256(
                         traderDepositsObjectString
@@ -30000,10 +30129,10 @@
                       );
 
                       const updatedDepositObject = {
-                        updatedTraderDepositObject: trader_deposits,
+                        updatedTraderDepositObject: trader_deposit_updated,
                         updatedDepositsObjectSign: traderDepositsObjectSign,
-                        trader_flo_address: trader_deposits.trader_flo_address,
-                        receiver_flo_address: trader_deposits.trader_flo_address
+                        trader_flo_address: trader_deposit_updated.trader_flo_address,
+                        receiver_flo_address: trader_deposit_updated.trader_flo_address
                       };
 
                       RM_RPC.send_rpc(