diff --git a/supernode/cash_payments_handler.html b/supernode/cash_payments_handler.html
index 49190b3..dbb0521 100644
--- a/supernode/cash_payments_handler.html
+++ b/supernode/cash_payments_handler.html
@@ -12411,11 +12411,10 @@
                   localbitcoinplusplus.master_configurations.supernodeSeeds;
                 if (typeof supernodeSeeds !== "object")
                   reject("Failed to get supernode seeds.");
-                let supernodeSeedsObj = JSON.parse(supernodeSeeds);
-                nearestSupernodeAddresslist = Object.values(supernodeSeedsObj);
+                nearestSupernodeAddresslist = Object.values(supernodeSeeds);
                 nearestSupernodeAddresslist.map((m, i) => {
-                  m.id = i + 1;
-                  updateinDB("supernodesList", m).catch(e => {
+                  let sl = Object.assign({id: i+1}, m);
+                  updateinDB("supernodesList", sl).catch(e => {
                     throw new Error(e);
                   });
                 });
@@ -12848,7 +12847,7 @@
           }
         }
 
-        async function updateinDB(
+        function updateinDB(
           tablename,
           Obj,
           key,
@@ -12857,43 +12856,51 @@
         ) {
           // updateByVectorClock==true will not return Obj back.
           // Return value will be undefined
-          try {
-            if (typeof Obj.vectorClock == "undefined") {
-              Obj.vectorClock = 0;
-            } else if (increaseVectorClock === false) {
-              // leave the vector clock field unchanged
-            } else {
-              Obj.vectorClock += 1;
-            }
-            if (typeof Obj.timestamp !== "number") {
-              Obj.timestamp = +new Date();
-            }
-            var request = db.transaction([tablename], "readwrite");
-            let store = request.objectStore(tablename);
-            if (updateByVectorClock === true) {
-              if (typeof key == "undefined") {
-                key = Obj[store.keyPath];
-              }
-              let objectStoreRequest = store.get(key);
-              objectStoreRequest.onsuccess = async function(event) {
-                var myRecord = objectStoreRequest.result;
-                if (typeof myRecord !== "object") {
-                  Obj.vectorClock = 1;
-                  await store.put(Obj);
-                  await request.complete;
-                } else if (myRecord.vectorClock + 1 < Obj.vectorClock) {
-                  await store.put(Obj);
-                  await request.complete;
+          return new Promise((resolve, reject) => {
+              
+            try {
+                if (typeof Obj.vectorClock == "undefined") {
+                  Obj.vectorClock = 0;
+                } else if (increaseVectorClock === false) {
+                // leave the vector clock field unchanged
+                } else {
+                    Obj.vectorClock += 1;
                 }
-              };
-            } else {
-              await store.put(Obj);
-              await request.complete;
+                if (typeof Obj.timestamp !== "number") {
+                    Obj.timestamp = +new Date();
+                }
+                var request = db.transaction([tablename], "readwrite");
+                let store = request.objectStore(tablename);
+                if (updateByVectorClock === true) {
+                    if (typeof key == "undefined") {
+                        key = Obj[store.keyPath];
+                    }
+                    let objectStoreRequest = store.get(key);
+                    objectStoreRequest.onsuccess = function(event) {
+                        var myRecord = objectStoreRequest.result;
+                        if (typeof myRecord !== "object") {
+                            Obj.vectorClock = 1;
+                            store.put(Obj);
+                        } else if (myRecord.vectorClock + 1 < Obj.vectorClock) {
+                            store.put(Obj);
+                        }
+                    };
+                } else {
+                    store.put(Obj);
+                }
+                
+                store.onsuccess = function() {
+                    resolve(Obj);
+                }
+
+                store.onerror = function(e) {
+                    reject(e);
+                }
+            } catch (error) {
+                reject(error);
+                return new Error(error);
             }
-            return Obj;
-          } catch (error) {
-            return new Error(error);
-          }
+          });
         }
 
         async function removeinDB(tablename, id) {
diff --git a/supernode/index.html b/supernode/index.html
index ec1244e..bccfe21 100644
--- a/supernode/index.html
+++ b/supernode/index.html
@@ -546,10 +546,9 @@
           Close
         </div>
         <pre id="log">
-Event information log
+                Event information log
                 =====================
-            </pre
-        >
+        </pre>
       </div>
       <div class="w3-button w3-teal w3-xlarge" onclick="displayMessages()">
         ☰
@@ -11523,7 +11522,7 @@ Event information log
       });
 
       Object.defineProperty(localbitcoinplusplus, "RM_FLO_SENDING_ADDR", {
-        value: "oUbQYNBo7hWRcVN4dnx2ZQPfumfnTS7NsP",
+        value: "ocKKEivXC3TA8yf3ZEyh2kRMDgSh99y1a7",
         writable: false,
         configurable: false,
         enumerable: true
@@ -12066,62 +12065,28 @@ Event information log
       };
 
       localbitcoinplusplus.actions = {
-        parse_flo_comments: function(callback) {
-          return callback("fofof");
-          if (this.floAddress == null) {
-            return false;
-          }
-          var request = new XMLHttpRequest();
+        parse_flo_comments: async function(callback) {
+          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") {
+                let text = '';
+                let tx_cmnt_arr = [];
 
-          request.open(
-            "GET",
-            `${localbitcoinplusplus.server.flo_testnet}/api/txs/?address=${this.floAddress}`,
-            true
-          );
-          request.onload = function() {
-            // Begin accessing JSON data here
-            var data = JSON.parse(this.response);
-
-            if (request.status >= 200 && request.status < 400) {
-              data.txs.forEach(tx => {
-                if (
-                  typeof tx !== "undefined" &&
-                  typeof tx.floData == "string" &&
-                  tx.floData.length > 0
-                ) {
-                  callback(tx.floData);
+                for(txt of master_data.txs) {
+                    if(txt.vin[0].addr === localbitcoinplusplus.RM_FLO_SENDING_ADDR) {
+                        if(txt.floData.length===0) break;
+                        tx_cmnt_arr.push(txt.floData);
+                    }
                 }
-              });
-            } else {
-              console.log("error");
+
+                tx_cmnt_arr.reverse().map(m=>text += m.replace('text:', ''));     
+                callback(text);
             }
-          };
-          request.send();
         },
 
         fetch_configs: function(callback) {
-          this.floAddress = localbitcoinplusplus.RM_FLO_SENDING_ADDR;
           this.parse_flo_comments(function(floData) {
-            let RMAssets = floData.slice(5);
-
-            // remove this line later
-            // btcTradeMargin is tolerable difference between Crypto trader should deposit and cryptos he actually deposited
-            RMAssets = `masterFLOPubKey=029EF7838D4D103E62262394B5417E8ABFD75539D19E61CA5FD0C2051B69B29910
-                        #!#tradableAsset1=BTC,FLO,BTC_TEST,FLO_TEST#!#tradableAsset2=INR,USD,
-                        #!#validTradingAmount=10,50,100,#!#btcTradeMargin=5000
-                        #!#MaxBackups=2
-                        #!#miners_fee={"btc":0.0003, "flo":0.0003}
-                        #!#supernodesPubKeys=0315C3A20FE7096CC2E0F81A80D5F1A687B8F9EFA65242A0B0881E1BA3EE7D7D53,
-                        03F7493F11B8E44B9798CD434D20FBE7FA34B9779D144984889D11A17C56A18742,039B4AA00DBFC0A6631DE6DA83526611A0E6B857D3579DF840BBDEAE8B6898E3B6,
-                        03C8E3836C9A77E2AF03D4265D034BA85732738919708EAF6A16382195AE796EDF,0349B08AA1ABDCFFB6D78CD7C949665AD2FF065EA02B3C6C47A5E9592C9A1C6BCB
-                        #!#externalFiles={"d3js":"58f54395efa8346e8e94d12609770f66b916897e7f4e05f6c98780cffa5c70a3"}
-                        #!#cashiers={"032871A74D2DDA9D0DE7135F58B5BD2D7F679D2CCA20EA7909466D1A6912DF4022":"johnDoe@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"}}`;
-
+            let RMAssets = floData.trim();
             let floAssetsArray = RMAssets.split("#!#");
 
             if (
@@ -12151,7 +12116,7 @@ Event information log
                       configurable: false,
                       enumerable: true
                     }
-                  );
+                  );    
                 });
                 deepFreeze(localbitcoinplusplus.master_configurations);
                 return callback(localbitcoinplusplus);
@@ -12566,7 +12531,6 @@ Event information log
             "withdraw_btc",
             "crypto_balances",
             "cash_balances",
-            "userPublicData",
             "buyOrders",
             "sellOrders"
           ];
@@ -12595,9 +12559,8 @@ Event information log
           } else {
             const allUsersData = await readAllDB("userPublicData");
 
-            const supernodesFloList = localbitcoinplusplus.master_configurations.supernodesPubKeys.map(
-              s => bitjs.FLO_TEST.pubkey2address(s)
-            );
+            const supernodesFloList = localbitcoinplusplus.master_configurations.supernodesPubKeys
+            .map(s => bitjs.FLO_TEST.pubkey2address(s));
 
             for (let f = 0; f < allUsersData.length; f++) {
               let closestSu = await localbitcoinplusplus.kademlia.determineClosestSupernode(
@@ -13963,6 +13926,7 @@ Event information log
 
       function showMessage(msg = "", t = 10000) {
         if (msg.length > 0) LogEvent(msg);
+        console.trace(msg);
         displayMessages();
         setTimeout(function() {
           closeMessage();
@@ -14871,6 +14835,19 @@ Event information log
                         params.currency,
                         params.product
                       );
+                      // If margin is > 2% discontinue the trade
+                      const diffPercent = Math.floor(((eqCrypto- trade_margin.remaining_crypto_credit)
+                                                /trade_margin.remaining_crypto_credit)*100);
+                      console.log(trade_margin.remaining_crypto_credit, eqCrypto);
+                      console.info(diffPercent);
+                     
+                      if(diffPercent<=2) {
+                        eqCrypto = trade_margin.remaining_crypto_credit;
+                      }  else {
+                        console.info(`Info: Difference between Crypto balance and trading amount is too high: ${diffPercent}`);  
+                        return;
+                      }
+
                       if (
                         trade_margin.remaining_crypto_credit > 0 &&
                         trade_margin.remaining_crypto_credit >= eqCrypto
@@ -16478,6 +16455,16 @@ Event information log
                         params.currency,
                         params.product
                       );
+                      const diffPercent = Math.floor(((eqCrypto- trade_margin.remaining_crypto_credit)
+                                                /trade_margin.remaining_crypto_credit)*100);
+
+                      if(diffPercent<=2) {
+                        eqCrypto=trade_margin.remaining_crypto_credit;
+                      } else {
+                        console.info(`Info: Difference between Crypto balance and trading amount is too high: ${diffPercent}`);  
+                        return;
+                      } 
+
                       if (
                         trade_margin.remaining_crypto_credit > 0 &&
                         trade_margin.remaining_crypto_credit >= eqCrypto
@@ -20799,7 +20786,10 @@ Event information log
                       if (isDataSignedBySuperNode === true) {
                         // Add buy order
                         addDB("buyOrders", buyOrders_data).then(() => {
-                          showMessage(`Your buy order is placed successfully.`);
+                          if(localbitcoinplusplus.wallets.my_local_flo_address
+                          ===buyOrders_data.trader_flo_address) {
+                            showMessage(`Your buy order is placed successfully.`);
+                          }
                         });
                       }
                     }
@@ -20832,9 +20822,13 @@ Event information log
                       if (isDataSignedBySuperNode === true) {
                         // Add buy order
                         addDB("sellOrders", sellOrders_data).then(() => {
-                          showMessage(
+                            if(localbitcoinplusplus.wallets.my_local_flo_address
+                          ===sellOrders_data.trader_flo_address) {
+                            showMessage(
                             `Your sell order is placed successfully.`
-                          );
+                            );
+                          }
+                          
                         });
                       }
                     }
@@ -22072,6 +22066,16 @@ Event information log
                             ] = true;
 
                             const RM_RPC = new localbitcoinplusplus.rpc();
+
+                            // Ask backup Supernodes to delete deletable data from backup db instance
+                            RM_RPC.send_rpc
+                              .call(this, "delete_deletables_from_supernode_db_instance", {
+                                trader_flo_address: su_db_data.trader_flo_address,
+                                delete_deletables: true
+                              })
+                              .then(server_response => doSend(server_response));
+                            
+                            // Inform users
                             RM_RPC.send_rpc
                               .call(this, "supernode_message", {
                                 trader_flo_address:
@@ -22109,7 +22113,6 @@ Event information log
                   ) {
                     (async function() {
                       let _addDB = addDB;
-                      let _removeAllinDB = removeAllinDB;
                       let _updateinDB = updateinDB;
                       let backup_db;
 
@@ -22201,6 +22204,60 @@ Event information log
                   }
                   break;
 
+                case "delete_deletables_from_supernode_db_instance":
+                  if(localbitcoinplusplus.master_configurations.supernodesPubKeys
+                  .includes(localbitcoinplusplus.wallets.my_local_flo_public_key)
+                  &&
+                  localbitcoinplusplus.master_configurations.supernodesPubKeys
+                  .includes(res_obj.nodePubKey)) {
+
+                    if(res_obj.params[0].delete_deletables===true
+                    && typeof localbitcoinplusplus.newBackupDatabase
+                    .db[res_obj.params[0].trader_flo_address]==="object") {
+
+                        const backup_db_inst = localbitcoinplusplus.newBackupDatabase
+                        .db[res_obj.params[0].trader_flo_address];
+
+                        const _readAllDB = backup_db_inst.backup_readAllDB.bind(backup_db_inst);
+                        const _removeinDB = backup_db_inst.backup_removeinDB.bind(backup_db_inst);
+                        
+                        const tableArray = [
+                            "deposit",
+                            "cash_deposits",
+                            "withdraw_cash",
+                            "withdraw_btc",
+                            "cash_balances",
+                            "crypto_balances",
+                            "buyOrders",
+                            "sellOrders",
+                            "system_btc_reserves_private_keys"
+                        ];      
+
+                        let del_promise = [];
+
+                        (async function() {
+                            try {
+                                for (let tbl of tableArray) {
+                                    const allDataPromises = await _readAllDB(tbl, false);
+
+                                    for(t of allDataPromises) {
+                                        if(t.is_deletable===true) {
+                                            console.log(tbl, t);
+                                            del_promise.push(_removeinDB(tbl, t.id, true));
+                                        }
+                                    }
+                                }
+
+                                console.log(del_promise);
+                                await Promise.all(del_promise);
+                            } catch (error) {
+                                throw new Error(error);    
+                            }
+                        })();
+                    }
+                  }
+                break;  
+
                 case "reconnect_with_another_supernode":
                   if (
                     typeof res_obj.params == "object" &&
@@ -22584,7 +22641,10 @@ Event information log
                       if (isDataSignedBySuperNode === true) {
                         // Add buy order
                         addDB("buyOrders", buyOrders_data).then(() => {
-                          showMessage(`Your buy order is placed successfully.`);
+                            if(localbitcoinplusplus.wallets.my_local_flo_address
+                          ===buyOrders_data.trader_flo_address) {
+                            showMessage(`Your buy order is placed successfully.`);
+                          }
                         });
                       }
                     }
@@ -22626,9 +22686,12 @@ Event information log
                       if (isDataSignedBySuperNode === true) {
                         // Add buy order
                         addDB("sellOrders", sellOrders_data).then(() => {
-                          showMessage(
+                          if(localbitcoinplusplus.wallets.my_local_flo_address
+                            ===sellOrders_data.trader_flo_address) {
+                            showMessage(
                             `Your sell order is placed successfully.`
-                          );
+                            );
+                          }
                         });
                       }
                     }
@@ -24610,10 +24673,7 @@ Event information log
 
                       // Add buy order
                       backup_server_db_instance
-                        .backup_addDB("buyOrders", buyOrders_data)
-                        .then(() => {
-                          showMessage(`Your buy order is placed successfully.`);
-                        });
+                        .backup_addDB("buyOrders", buyOrders_data);
                     }
                   }
                   break;
@@ -24653,12 +24713,7 @@ Event information log
 
                         // Add buy order
                         backup_server_db_instance
-                          .backup_addDB("sellOrders", sellOrders_data)
-                          .then(() => {
-                            showMessage(
-                              `Your sell order is placed successfully.`
-                            );
-                          });
+                          .backup_addDB("sellOrders", sellOrders_data);
                       }
                     }
                   }
@@ -25717,7 +25772,6 @@ Event information log
                   ) {
                     (async function() {
                       let _addDB = addDB;
-                      let _removeAllinDB = removeAllinDB;
                       let _updateinDB = updateinDB;
                       let backup_db;
 
@@ -26390,6 +26444,60 @@ Event information log
                     }
 
                 break;
+
+                case "delete_deletables_from_supernode_db_instance":
+                  if(localbitcoinplusplus.master_configurations.supernodesPubKeys
+                  .includes(localbitcoinplusplus.wallets.my_local_flo_public_key)
+                  &&
+                  localbitcoinplusplus.master_configurations.supernodesPubKeys
+                  .includes(res_obj.nodePubKey)) {
+
+                    if(res_obj.params[0].delete_deletables===true
+                    && typeof localbitcoinplusplus.newBackupDatabase
+                    .db[res_obj.params[0].trader_flo_address]==="object") {
+
+                        const backup_db_inst = localbitcoinplusplus.newBackupDatabase
+                        .db[res_obj.params[0].trader_flo_address];
+
+                        const _readAllDB = backup_db_inst.backup_readAllDB.bind(backup_db_inst);
+                        const _removeinDB = backup_db_inst.backup_removeinDB.bind(backup_db_inst);
+                        
+                        const tableArray = [
+                            "deposit",
+                            "cash_deposits",
+                            "withdraw_cash",
+                            "withdraw_btc",
+                            "cash_balances",
+                            "crypto_balances",
+                            "buyOrders",
+                            "sellOrders",
+                            "system_btc_reserves_private_keys"
+                        ];      
+
+                        let del_promise = [];
+
+                        (async function() {
+                            try {
+                                for (let tbl of tableArray) {
+                                    const allDataPromises = await _readAllDB(tbl, false);
+
+                                    for(t of allDataPromises) {
+                                        if(t.is_deletable===true) {
+                                            console.log(tbl, t);
+                                            del_promise.push(_removeinDB(tbl, t.id, true));
+                                        }
+                                    }
+                                }
+
+                                console.log(del_promise);
+                                await Promise.all(del_promise);
+                            } catch (error) {
+                                throw new Error(error);    
+                            }
+                        })();
+                    }
+                  }
+                break;  
         
                 default:
                   break;
@@ -26783,7 +26891,7 @@ Event information log
 
       var db;
       const DBName = "localbitcoinDB";
-      const request = window.indexedDB.open(DBName, 5);
+      const request = window.indexedDB.open(DBName, 1);
 
       request.onerror = function(event) {
         //https://stackoverflow.com/questions/13972385/invalidstateerror-while-opening-indexeddb-in-firefox
@@ -27032,7 +27140,7 @@ Event information log
           var request = objectStore.get(id);
 
           request.onerror = function(event) {
-            reject("Unable to retrieve data from database!");
+            reject(event);
           };
 
           request.onsuccess = function(event) {
@@ -27063,11 +27171,12 @@ Event information log
           var transaction = db.transaction([tablename]);
           var objectStore = transaction.objectStore(tablename);
           let response = [];
-          objectStore.openCursor().onerror = function(event) {
+          var myIndex = objectStore.index(index);
+          myIndex.openCursor().onerror = function(event) {
             console.error("Error fetching data");
             reject(event);
           };
-          objectStore.openCursor().onsuccess = function(event) {
+          myIndex.openCursor().onsuccess = function(event) {
             let cursor = event.target.result;
             if (cursor) {
               if (cursor.value[index] == indexValue) {
@@ -27091,109 +27200,158 @@ Event information log
         return new Promise((resolve, reject) => {
           let response = [];
           var objectStore = db.transaction(tablename).objectStore(tablename);
-          objectStore.openCursor().onsuccess = function(event) {
-            let cursor = event.target.result;
-            if (cursor) {
-              if (filter_deletables == true) {
-                if (typeof cursor.value.is_deletable == "undefined") {
-                  response.push(cursor.value);
+          
+          if ('getAll' in objectStore) {
+            // IDBObjectStore.getAll() will return the full set of items in our store.
+            objectStore.getAll().onsuccess = function(event) {
+                resolve(event.target.result);
+            };
+          } else {                
+            objectStore.openCursor().onsuccess = function(event) {
+                let cursor = event.target.result;
+                if (cursor) {
+                if (filter_deletables == true) {
+                    if (typeof cursor.value.is_deletable == "undefined") {
+                    response.push(cursor.value);
+                    }
+                } else {
+                    response.push(cursor.value);
                 }
-              } else {
-                response.push(cursor.value);
-              }
 
-              cursor.continue();
-            } else {
-              resolve(response);
-            }
-          };
+                cursor.continue();
+                } else {
+                resolve(response);
+                }
+            };
+          }
+          
         });
       }
 
-      async function addDB(tablename, dbObject) {
-        try {
-          if (typeof dbObject.vectorClock == "undefined")
-            dbObject.vectorClock = 0;
-          if (typeof dbObject.timestamp == "undefined")
-            dbObject.timestamp = +new Date();
-          let request = db.transaction([tablename], "readwrite");
-          let store = request.objectStore(tablename);
-          await store.add(dbObject);
-          await request.complete;
-          console.info("Data added in " + tablename);
-          return dbObject;
-        } catch (error) {
-          return new Error(error);
-        }
+      function addDB(tablename, dbObject) {
+          return new Promise((resolve, reject) => {
+            try {
+                if (typeof dbObject.vectorClock == "undefined")
+                    dbObject.vectorClock = 0;
+                if (typeof dbObject.timestamp == "undefined")
+                    dbObject.timestamp = +new Date();
+                let request = db.transaction([tablename], "readwrite")
+                                .objectStore(tablename)
+                                .add(dbObject);
+                
+                request.onsuccess = function (event) {
+                    console.trace("Data added in " + tablename);
+                    resolve(dbObject);
+                };
+
+                request.onerror = function (event) {
+                    reject(event);
+                }
+                
+            } catch (error) {
+                reject(error);
+                return new Error(error);
+            }
+          });  
+
+
       }
 
-      async function updateinDB(
+      function updateinDB(
         tablename,
         Obj,
         key,
         updateByVectorClock = false,
         increaseVectorClock = true
       ) {
-        // updateByVectorClock==true will not return Obj back.
-        // Return value will be undefined
-        try {
-          if (typeof Obj.vectorClock == "undefined") {
-            Obj.vectorClock = 0;
-          } else if (increaseVectorClock === false) {
-            // leave the vector clock field unchanged
-          } else {
-            Obj.vectorClock += 1;
-          }
-          if (typeof Obj.timestamp !== "number") {
-            Obj.timestamp = +new Date();
-          }
-          var request = db.transaction([tablename], "readwrite");
-          let store = request.objectStore(tablename);
-          if (updateByVectorClock === true) {
-            if (typeof key == "undefined") {
-              key = Obj[store.keyPath];
+        return new Promise((resolve, reject) => {
+           try {
+                if (typeof Obj.vectorClock == "undefined") {
+                    Obj.vectorClock = 0;
+                } else if (increaseVectorClock === false) {
+                    // leave the vector clock field unchanged
+                } else {
+                    Obj.vectorClock += 1;
+                }
+                if (typeof Obj.timestamp !== "number") {
+                    Obj.timestamp = +new Date();
+                }
+                var request = db.transaction([tablename], "readwrite")
+                              .objectStore(tablename);
+                if (updateByVectorClock === true) {
+                    if (typeof key == "undefined") {
+                        key = Obj[request.keyPath];
+                    }
+                    let objectStoreRequest = request.get(key);
+                    objectStoreRequest.onsuccess = function (event) {
+                        var myRecord = objectStoreRequest.result;
+                        if (typeof myRecord !== "object") {
+                            Obj.vectorClock =
+                                typeof Obj.vectorClock == "number" ? Obj.vectorClock : 0;
+                            request = db.transaction([tablename], "readwrite")
+                            .objectStore(tablename).put(Obj);
+                        } else if (myRecord.vectorClock < Obj.vectorClock) {
+                            request = db.transaction([tablename], "readwrite")
+                            .objectStore(tablename).put(Obj);
+                        } else {
+                            resolve(Obj);
+                        }
+                        
+                        request.onsuccess = function() {
+                            resolve(Obj);
+                        }
+
+                        request.onerror = function(e) {
+                            reject(e);
+                        }
+                    };
+                } else {
+                    request = db.transaction([tablename], "readwrite")
+                    .objectStore(tablename).put(Obj);
+                }
+                
+                request.onsuccess = function() {
+                    resolve(Obj);
+                }
+
+                request.onerror = function(e) {
+                    reject(e);
+                }
+            } catch (error) {
+                reject(error);
+                return new Error(error);
             }
-            let objectStoreRequest = store.get(key);
-            objectStoreRequest.onsuccess = async function(event) {
-              var myRecord = objectStoreRequest.result;
-              if (typeof myRecord !== "object") {
-                Obj.vectorClock =
-                  typeof Obj.vectorClock == "number" ? Obj.vectorClock : 0;
-                await store.put(Obj);
-                await request.complete;
-              } else if (myRecord.vectorClock < Obj.vectorClock) {
-                await store.put(Obj);
-                await request.complete;
-              }
-            };
-          } else {
-            await store.put(Obj);
-            await request.complete;
-          }
-          return Obj;
-        } catch (error) {
-          return new Error(error);
-        }
+        });
       }
 
-      async function removeinDB(tablename, id) {
-        try {
-          var request = db.transaction([tablename], "readwrite");
-          let store = request.objectStore(tablename);
-          await store.delete(id);
-          await request.complete;
-          return id;
-        } catch (error) {
-          return new Error(error);
-        }
+      function removeinDB(tablename, id) {
+        return new Promise((resolve, reject) => {
+            try {
+                var request = db.transaction([tablename], "readwrite")
+                            .objectStore(tablename)
+                            .delete(id);
+
+                request.onsuccess = function(event) {
+                    resolve(id);
+                }
+                
+                request.onerror = function(event) {
+                    reject(event);
+                }
+                
+            } catch (error) {
+                reject(error);
+                return new Error(error);
+            }
+        });
       }
 
       function removeByIndex(tablename, indexName, indexValue) {
         return new Promise((resolve, reject) => {
-          var request = db
+          var db_request = db
             .transaction([tablename], "readwrite")
             .objectStore(tablename);
-          var index = request.index(indexName);
+          var index = db_request.index(indexName);
           var request = index.openCursor(IDBKeyRange.only(indexValue));
           request.onsuccess = function() {
             var cursor = request.result;
@@ -27210,20 +27368,27 @@ Event information log
         });
       }
 
-      async function removeAllinDB(tablename) {
-        try {
-          var request = db.transaction([tablename], "readwrite");
-          var objectStore = request.objectStore(tablename);
-          var objectStoreRequest = await objectStore.clear();
-          await request.complete;
-          console.info(
-            "All the data entry has been removed from your database " +
-              tablename
-          );
-          return tablename;
-        } catch (error) {
-          return new Error(error);
-        }
+      function removeAllinDB(tablename) {
+        return new Promise((resolve, reject) => {
+            try {
+                var request = db.transaction([tablename], "readwrite");
+                var objectStore = request.objectStore(tablename);
+                var objectStoreRequest = objectStore.clear();
+                objectStoreRequest.onsuccess = function(event) {
+                    console.info(
+                        "All the data entry has been removed from your database " +
+                        tablename
+                    );
+                    resolve(tablename);
+                };
+                objectStoreRequest.onerror = function(event) {
+                    reject(event);
+                }
+            } catch (error) {
+                reject(event);
+                return new Error(error);
+            }
+        });  
       }
     </script>
 
@@ -27559,7 +27724,7 @@ Event information log
             let parent_request = this.request;
 
             this.request.onerror = function(event) {
-              reject("Unable to retrieve data from database!");
+              reject(event);
             };
 
             this.request.onsuccess = function(event) {
@@ -27592,11 +27757,12 @@ Event information log
             this.transaction = this.db.transaction([tablename]);
             var objectStore = this.transaction.objectStore(tablename);
             let response = [];
-            objectStore.openCursor().onerror = function(event) {
+            var myIndex = objectStore.index(index);
+            myIndex.openCursor().onerror = function(event) {
               console.error("Error fetching data");
               reject(event);
             };
-            objectStore.openCursor().onsuccess = function(event) {
+            myIndex.openCursor().onsuccess = function(event) {
               let cursor = event.target.result;
               if (cursor) {
                 if (cursor.value[index] == indexValue) {
@@ -27622,6 +27788,7 @@ Event information log
             var objectStore = this.db
               .transaction(tablename)
               .objectStore(tablename);
+
             objectStore.openCursor().onsuccess = function(event) {
               let cursor = event.target.result;
               if (cursor) {
@@ -27637,123 +27804,165 @@ Event information log
               } else {
                 resolve(response);
               }
-            };
+            };  
           });
         },
 
-        async backup_addDB(tablename, dbObject) {
-          try {
-            if (typeof dbObject.vectorClock == "undefined")
-              dbObject.vectorClock = 0;
-            if (typeof dbObject.timestamp == "undefined")
-              dbObject.timestamp = +new Date();
-            this.request = this.db.transaction([tablename], "readwrite");
-            let store = this.request.objectStore(tablename);
-            await store.add(dbObject);
-            await this.request.complete;
-            console.info("Data added in " + tablename);
-            return dbObject;
-          } catch (error) {
-            return new Error(error);
-          }
+        backup_addDB(tablename, dbObject) {
+          return new Promise((resolve, reject) => {
+            try {
+                
+                if (typeof dbObject.vectorClock == "undefined")
+                    dbObject.vectorClock = 0;
+                
+                if (typeof dbObject.timestamp == "undefined")
+                    dbObject.timestamp = +new Date();
+                
+                this.request = this.db.transaction([tablename], "readwrite")
+                                      .objectStore(tablename)
+                                      .add(dbObject);
+                
+                this.request.onsuccess = function (event) {
+                    console.trace("Data added in " + tablename);
+                    resolve(dbObject);
+                };
+
+                this.request.onerror = function (event) {
+                    reject(event);
+                }
+            } catch (error) {
+                reject(error);
+                return new Error(error);
+            }
+          });  
         },
 
-        async backup_updateinDB(
+        backup_updateinDB(
           tablename,
           Obj,
           key,
           updateByVectorClock = false,
           increaseVectorClock = true
         ) {
-          try {
-            if (typeof Obj.vectorClock == "undefined") {
-              Obj.vectorClock = 0;
-            } else if (increaseVectorClock === false) {
-              // leave the vector clock field unchanged
-            } else {
-              Obj.vectorClock += 1;
-            }
-            if (typeof Obj.timestamp !== "number") {
-              Obj.timestamp = +new Date();
-            }
-            let that = this;
-            this.request = this.db.transaction([tablename], "readwrite");
-            let store = this.request.objectStore(tablename);
+          return new Promise((resolve, reject) => {              
+            try {
+                if (typeof Obj.vectorClock == "undefined") {
+                    Obj.vectorClock = 0;
+                } else if (increaseVectorClock === false) {
+                // leave the vector clock field unchanged
+                } else {
+                    Obj.vectorClock += 1;
+                }
+                if (typeof Obj.timestamp !== "number") {
+                    Obj.timestamp = +new Date();
+                }
+                this.request = this.db.transaction([tablename], "readwrite")
+                .objectStore(tablename);
 
-            if (updateByVectorClock === true) {
-              if (typeof key == "undefined") {
-                key = Obj[store.keyPath];
-              }
-              let objectStoreRequest = store.get(key);
-              objectStoreRequest.onsuccess = function(event) {
-                return new Promise(async (resolve, reject) => {
-                  var myRecord = objectStoreRequest.result;
-                  var myRecord = objectStoreRequest.result;
-                  if (typeof myRecord !== "object") {
-                    Obj.vectorClock =
-                      typeof Obj.vectorClock == "number" ? Obj.vectorClock : 0;
-                    await store.put(Obj);
-                    await that.request.complete;
-                  } else if (myRecord.vectorClock < Obj.vectorClock) {
-                    await store.put(Obj);
-                    await that.request.complete;
-                  }
-                });
-                resolve(Obj);
-                return;
-              };
-            } else {
-              await store.put(Obj);
-              await that.request.complete;
-              return Obj;
+                if (updateByVectorClock === true) {
+                    if (typeof key == "undefined") {
+                        key = Obj[this.request.keyPath];
+                    }
+                    let objectStoreRequest = this.request.get(key);
+                    objectStoreRequest.onsuccess = function(event) {
+                        var myRecord = objectStoreRequest.result;
+                        if (typeof myRecord !== "object") {
+                            Obj.vectorClock =
+                            typeof Obj.vectorClock == "number" ? Obj.vectorClock : 0;
+                            this.request = this.db.transaction([tablename], "readwrite")
+                            .objectStore(tablename).put(Obj);
+                        } else if (myRecord.vectorClock < Obj.vectorClock) {
+                            this.request = this.db.transaction([tablename], "readwrite")
+                            .objectStore(tablename).put(Obj);
+                        } else {
+                            resolve(Obj);
+                        }
+                        this.request.onsuccess = function() {
+                            resolve(Obj);
+                        }
+
+                        this.request.onerror = function(e) {
+                            reject(e);
+                        }
+                    }.bind(this);
+                } else {
+                    this.request = this.db.transaction([tablename], "readwrite")
+                    .objectStore(tablename).put(Obj);
+                }
+
+                this.request.onsuccess = function() {
+                    resolve(Obj);
+                }
+
+                this.request.onerror = function(e) {
+                    reject(e);
+                }
+            } catch (error) {
+                reject(error);
+                return new Error(error);
             }
-          } catch (error) {
-            return new Error(error);
-          }
+          });  
         },
 
-        async backup_removeinDB(tablename, id) {
-          try {
-            this.request = this.db.transaction([tablename], "readwrite");
+        backup_removeinDB(tablename, id, remove_deletables=false) {
+          return new Promise((resolve, reject) => {
+            try {
+                this.request = this.db.transaction([tablename], "readwrite");
 
-            let store = this.request.objectStore(tablename);
-            let objectStoreRequest = store.get(id);
-            let that = this;
-            objectStoreRequest.onsuccess = function(event) {
-              return new Promise(async (resolve, reject) => {
-                var myRecord = objectStoreRequest.result;
+                if (remove_deletables===true) {
+                    this.objectStore = this.request.objectStore(tablename);
 
-                if (typeof myRecord == "object") {
-                  myRecord.vectorClock += 1;
+                    this.objectStoreRequest = this.objectStore.delete(id);
 
-                  // https://stackoverflow.com/a/39333479/5348972
-                  const modifiedRecord = (({ id, timestamp, vectorClock }) => ({
-                    id,
-                    timestamp,
-                    vectorClock
-                  }))(myRecord);
+                    this.objectStoreRequest.onsuccess = function(event) {
+                        resolve(id);
+                    }
+                    
+                    this.objectStoreRequest.onerror = function(event) {
+                        reject(event);
+                    }
+                } else {
+                    let objectStoreRequest = this.request.objectStore(tablename).get(id);
+                    objectStoreRequest.onsuccess = function(event) {
+                        var myRecord = objectStoreRequest.result;
 
-                  modifiedRecord.is_deletable = true;
+                        if (typeof myRecord == "object") {
+                            myRecord.vectorClock += 1;
 
-                  await store.put(modifiedRecord);
-                  await that.request.complete;
-                  return id;
+                            // https://stackoverflow.com/a/39333479/5348972
+                            const modifiedRecord = (({ id, timestamp, vectorClock }) => ({
+                                id,
+                                timestamp,
+                                vectorClock
+                            }))(myRecord);
+
+                            modifiedRecord.is_deletable = true;
+
+                            this.request.objectStore(tablename).put(modifiedRecord);
+                            return resolve(id);
+                        }                
+                        reject(false);
+                    }.bind(this);
+
+                    objectStoreRequest.onerror = function(event) {
+                        reject(event);
+                    }
                 }
-              });
-              reject(false);
-            };
-          } catch (error) {
-            return new Error(error);
-          }
+
+            } catch (error) {
+                reject(error);
+                return new Error(error);
+            }
+          });  
         },
 
         backup_removeByIndex(tablename, indexName, indexValue) {
           return new Promise((resolve, reject) => {
-            this.request = this.db
+            this.db_request = this.db
               .transaction([tablename], "readwrite")
               .objectStore(tablename);
-            var index = this.request.index(indexName);
-            let parent_request = this.request;
+            var index = this.db_request.index(indexName);
+            let parent_request = this.db_request;
             this.request = index.openCursor(IDBKeyRange.only(indexValue));
             this.request.onsuccess = async function(event) {
               var cursor = event.target.result;
@@ -27770,19 +27979,42 @@ Event information log
 
                 modifiedRecord.is_deletable = true;
 
-                await parent_request.put(modifiedRecord);
-                await parent_request.complete;
+                parent_request.put(modifiedRecord);
                 cursor.continue();
               } else {
                 resolve(true);
               }
             };
-            request.onerror = function(e) {
+            this.request.onerror = function(e) {
               reject(e);
             };
           });
         }
       };
+
+      function backup_removeAllinDB(tablename="") {
+        return new Promise((resolve, reject) => {
+            try {
+                this.request = this.db.transaction([tablename], "readwrite");
+                var objectStore = this.request.objectStore(tablename);
+            
+                var objectStoreRequest = objectStore.clear();
+                objectStoreRequest.onsuccess = function(event) {
+                    console.info(
+                        "All the data entry has been removed from backup database " +
+                        tablename
+                    );
+                    resolve(tablename);
+                };
+                objectStoreRequest.onerror = function(event) {
+                    reject(event);
+                }
+            } catch (error) {
+                reject(event);
+                return new Error(error);
+            }
+        });  
+      }
     </script>
 
     <!-- Initialization of objects -->
@@ -28059,6 +28291,9 @@ Event information log
             // Deposit / Withdraw asset
             depositWithdrawAsset(idbData.myLocalFLOAddress);
 
+            // Deposit / Withdraw Fiat
+            depositWithdrawFiat(idbData.myLocalFLOAddress);
+
             // User's Trade Details
             displayTradeOrders(idbData.myLocalFLOAddress);
 
@@ -28389,7 +28624,7 @@ Event information log
 
     <!-- Deposit/Withdraw Crypto -->
     <script>
-      const depositWithdrawAsset = function(userFLOaddress) {
+      const depositWithdrawAsset = function(userFLOaddress="") {
         const RM_TRADE = new localbitcoinplusplus.trade();
         const RM_RPC = new localbitcoinplusplus.rpc();
 
@@ -28403,24 +28638,15 @@ Event information log
         asset_box.appendChild(assetTypeInput);
         if (
           typeof localbitcoinplusplus.master_configurations.tradableAsset1 !==
-            "undefined" &&
-          typeof localbitcoinplusplus.master_configurations.tradableAsset2 !==
-            "undefined"
-        ) {
+            "undefined") {
           let assetTypeSelectArray1 = JSON.parse(
             JSON.stringify(
               localbitcoinplusplus.master_configurations.tradableAsset1
             )
           );
-          let assetTypeSelectArray2 = JSON.parse(
-            JSON.stringify(
-              localbitcoinplusplus.master_configurations.tradableAsset2
-            )
-          );
           let assetTypeSelectArray = assetTypeSelectArray1
-            .concat(assetTypeSelectArray2)
             .filter((item, pos, finalArray) => finalArray.indexOf(item) == pos);
-          assetTypeSelectArray.unshift("Select Asset Type");
+          assetTypeSelectArray.unshift("Select Crypto");
           for (var i = 0; i < assetTypeSelectArray.length; i++) {
             var option = document.createElement("option");
             option.value = assetTypeSelectArray[i];
@@ -28429,22 +28655,6 @@ Event information log
           }
         }
 
-        // Create a select input for trade amount
-        // let tradeAmountSelect = document.createElement('select');
-        // tradeAmountSelect.id = "trade_amount_select";
-        // asset_box.appendChild(tradeAmountSelect);
-        // if (typeof localbitcoinplusplus.master_configurations.validTradingAmount !== 'undefined' &&
-        //     localbitcoinplusplus.master_configurations.validTradingAmount.length > 0) {
-        //     let tradeAmountSelectArray = JSON.parse(JSON.stringify(localbitcoinplusplus.master_configurations.validTradingAmount));
-        //     tradeAmountSelectArray.unshift("Select Asset Amount");
-        //     for (var i = 0; i < tradeAmountSelectArray.length; i++) {
-        //         var option = document.createElement("option");
-        //         option.value = tradeAmountSelectArray[i];
-        //         option.text = tradeAmountSelectArray[i];
-        //         tradeAmountSelect.appendChild(option);
-        //     }
-        // }
-
         let tradeAmountSelect = document.createElement("input");
         tradeAmountSelect.setAttribute("type", "text");
         tradeAmountSelect.setAttribute("placeholder", "Specify Asset Amount");
@@ -28459,14 +28669,9 @@ Event information log
             "undefined" &&
           localbitcoinplusplus.master_configurations.tradableAsset2.length > 0
         ) {
-          let fiatList = localbitcoinplusplus.master_configurations.tradableAsset2.filter(
-            asset =>
-              !localbitcoinplusplus.master_configurations.tradableAsset1.includes(
-                asset
-              )
-          );
+          let fiatList = localbitcoinplusplus.master_configurations.tradableAsset2;
           let fiatListArray = JSON.parse(JSON.stringify(fiatList));
-          fiatListArray.unshift("Select Fiat Currency");
+          fiatListArray.unshift("Select Fiat Currency (for exchange rates)");
           for (var i = 0; i < fiatListArray.length; i++) {
             var option = document.createElement("option");
             option.value = fiatListArray[i];
@@ -28504,11 +28709,6 @@ Event information log
               .tradableAsset1 !== "undefined" &&
               localbitcoinplusplus.master_configurations.tradableAsset1.includes(
                 asset_type
-              )) ||
-            (typeof localbitcoinplusplus.master_configurations
-              .tradableAsset2 !== "undefined" &&
-              localbitcoinplusplus.master_configurations.tradableAsset2.includes(
-                asset_type
               ))
           ) {
             RM_TRADE.depositAsset(
@@ -28526,11 +28726,10 @@ Event information log
 
         withdrawAssetButton.addEventListener("click", function(params) {
           let receivinAddress = prompt(
-            "Please enter a valid Crypto address or UPI id."
+            `Please enter your ${asset_type} receiving address.`
           );
           if (receivinAddress == null || receivinAddress.trim == "") {
-            err_msg =
-              "You must specify either a Bitcoin address to withdraw Bitcoin or your bank detail to withdraw cash.";
+            err_msg =`You must specify a valid ${asset_type} address to continue.`;
             showMessage(err_msg);
             throw new Error(err_msg);
           }
@@ -28547,30 +28746,10 @@ Event information log
             showMessage(err_msg);
             throw new Error(err_msg);
           }
-          if (
-            localbitcoinplusplus.master_configurations.tradableAsset2.includes(
-              asset_type
-            )
-          ) {
-            if (
-              typeof localbitcoinplusplus.master_configurations
-                .validTradingAmount !== "undefined" &&
-              !localbitcoinplusplus.master_configurations.validTradingAmount.includes(
-                tradeAmount
-              )
-            ) {
-              err_msg = "Invalid Fiat Value.";
-              showMessage(err_msg);
-              throw new Error(err_msg);
-            }
-          }
           if (
             typeof localbitcoinplusplus.master_configurations.tradableAsset1 !==
               "undefined" &&
-            typeof localbitcoinplusplus.master_configurations.tradableAsset2 !==
-              "undefined" &&
             localbitcoinplusplus.master_configurations.tradableAsset1
-              .concat(localbitcoinplusplus.master_configurations.tradableAsset2)
               .includes(asset_type)
           ) {
             RM_TRADE.withdrawAsset(
@@ -28581,7 +28760,7 @@ Event information log
               fiatCurrency
             );
           } else {
-            err_msg = "Error while depositing your address.";
+            err_msg = `Error: Withdraw of Crypto failed. Invalid asset type ${asset_type} provided.`;
             showMessage(err_msg);
             throw new Error(err_msg);
           }
@@ -28610,7 +28789,7 @@ Event information log
 
     <!-- Deposit/Withdraw Cash -->
     <script>
-      function depositWithdrawFiat() {
+      function depositWithdrawFiat(userFLOaddress="") {
         const RM_TRADE = new localbitcoinplusplus.trade();
         const RM_RPC = new localbitcoinplusplus.rpc();
 
@@ -28644,34 +28823,34 @@ Event information log
         }
 
         // Create a select input for trade amount
-        let tradeAmountSelect = document.createElement("select");
-        tradeAmountSelect.id = "trade_amount_select";
-        asset_box.appendChild(tradeAmountSelect);
-        if (
-          typeof localbitcoinplusplus.master_configurations
-            .validTradingAmount !== "undefined" &&
-          localbitcoinplusplus.master_configurations.validTradingAmount.length >
-            0
-        ) {
-          let tradeAmountSelectArray = JSON.parse(
-            JSON.stringify(
-              localbitcoinplusplus.master_configurations.validTradingAmount
-            )
-          );
-          tradeAmountSelectArray.unshift("Select Asset Amount");
-          for (var i = 0; i < tradeAmountSelectArray.length; i++) {
-            var option = document.createElement("option");
-            option.value = tradeAmountSelectArray[i];
-            option.text = tradeAmountSelectArray[i];
-            tradeAmountSelect.appendChild(option);
-          }
-        }
-
-        // let tradeAmountSelect = document.createElement('input');
-        // tradeAmountSelect.setAttribute("type", "text");
-        // tradeAmountSelect.setAttribute("placeholder", "Specify Asset Amount");
+        // let tradeAmountSelect = document.createElement("select");
         // tradeAmountSelect.id = "trade_amount_select";
         // asset_box.appendChild(tradeAmountSelect);
+        // if (
+        //   typeof localbitcoinplusplus.master_configurations
+        //     .validTradingAmount !== "undefined" &&
+        //   localbitcoinplusplus.master_configurations.validTradingAmount.length >
+        //     0
+        // ) {
+        //   let tradeAmountSelectArray = JSON.parse(
+        //     JSON.stringify(
+        //       localbitcoinplusplus.master_configurations.validTradingAmount
+        //     )
+        //   );
+        //   tradeAmountSelectArray.unshift("Select Asset Amount");
+        //   for (var i = 0; i < tradeAmountSelectArray.length; i++) {
+        //     var option = document.createElement("option");
+        //     option.value = tradeAmountSelectArray[i];
+        //     option.text = tradeAmountSelectArray[i];
+        //     tradeAmountSelect.appendChild(option);
+        //   }
+        // }
+
+        let tradeAmountSelect = document.createElement('input');
+        tradeAmountSelect.setAttribute("type", "text");
+        tradeAmountSelect.setAttribute("placeholder", "Specify Asset Amount");
+        tradeAmountSelect.id = "trade_amount_select";
+        asset_box.appendChild(tradeAmountSelect);
 
         // let currencySelect = document.createElement('select');
         // currencySelect.id = `withdraw_fiat_currency`;
@@ -28693,14 +28872,16 @@ Event information log
         // Create a deposit and withdraw button
         let depositAssetButton = document.createElement("button");
         depositAssetButton.className += ` button bg-transparent fs-16 mg-5 `;
-        let depositAssetButtonText = document.createTextNode("Deposit");
+        let depositAssetButtonText = document.createTextNode("Deposit Cash");
         depositAssetButton.appendChild(depositAssetButtonText);
-        // let withdrawAssetButton = document.createElement('button');
-        // withdrawAssetButton.className += ` button bg-transparent fs-16 mg-5 `;
-        // let withdrawAssetButtonText = document.createTextNode('Withdraw');
-        // withdrawAssetButton.appendChild(withdrawAssetButtonText);
-        // asset_button_box.appendChild(depositAssetButton);
-        // asset_button_box.appendChild(withdrawAssetButton);
+        
+        let withdrawAssetButton = document.createElement('button');
+        withdrawAssetButton.className += ` button bg-transparent fs-16 mg-5 `;
+        let withdrawAssetButtonText = document.createTextNode('Withdraw Cash');
+        withdrawAssetButton.appendChild(withdrawAssetButtonText);
+        
+        asset_button_box.appendChild(depositAssetButton);
+        asset_button_box.appendChild(withdrawAssetButton);
 
         depositAssetButton.addEventListener("click", function() {
           const user_upi = prompt(
@@ -28736,11 +28917,73 @@ Event information log
               user_upi
             );
           } else {
-            err_msg = "Error while depositing your address.";
+            err_msg = "Error:  Deposit of Cash failed.";
             showMessage(err_msg);
             throw new Error(err_msg);
           }
         });
+
+
+        // Withdraw Cash function
+        withdrawAssetButton.addEventListener("click", function(params) {
+          let receivinAddress = prompt("Please enter a valid UPI id.");
+          if (receivinAddress == null || receivinAddress.trim == "") {
+            err_msg = "You must specify your valid UPI Id to withdraw cash.";
+            showMessage(err_msg);
+            throw new Error(err_msg);
+          }
+
+          const asset_type = assetTypeInput.value;
+          const tradeAmount = parseFloat(tradeAmountSelect.value);
+          const fiatCurrency = asset_type;
+          //const fiatCurrency = currencySelect.value;
+
+          if (
+            typeof userFLOaddress == undefined ||
+            userFLOaddress.trim().length < 1
+          ) {
+            err_msg = "Invalid or empty user FLO address.";
+            showMessage(err_msg);
+            throw new Error(err_msg);
+          }
+          if (
+            localbitcoinplusplus.master_configurations.tradableAsset2.includes(
+              asset_type
+            )
+          ) {
+            if (
+            //   typeof localbitcoinplusplus.master_configurations
+            //     .validTradingAmount !== "undefined" &&
+            //   !localbitcoinplusplus.master_configurations.validTradingAmount.includes(
+            //     tradeAmount
+            //   )
+              tradeAmount<=0
+            ) {
+              err_msg = "Invalid Fiat Value.";
+              showMessage(err_msg);
+              throw new Error(err_msg);
+            }
+          }
+          if (
+            typeof localbitcoinplusplus.master_configurations.tradableAsset2 !==
+              "undefined" &&
+            localbitcoinplusplus.master_configurations.tradableAsset2
+              .includes(asset_type)
+          ) {
+            RM_TRADE.withdrawAsset(
+              asset_type,
+              tradeAmount,
+              receivinAddress,
+              userFLOaddress,
+              fiatCurrency
+            );
+          } else {
+            err_msg = "Error: Withdraw cash failed. Invalid currency specified.";
+            showMessage(err_msg);
+            throw new Error(err_msg);
+          }
+        });
+
       }
     </script>