diff --git a/supernode/index.html b/supernode/index.html
index d759061..567e5b2 100644
--- a/supernode/index.html
+++ b/supernode/index.html
@@ -8653,7 +8653,512 @@
         
         })("secp256k1"); // End of EllipticCurveEncryption Object
         
-        </script>
+    </script>
+
+    <!-- Kademelia -->
+    <script>
+        /*Kademlia DHT K-bucket implementation as a binary tree.*/
+
+        if (typeof reactor == "undefined" || !reactor) {
+            (function () {
+
+                function Event(name) {
+                    this.name = name;
+                    this.callbacks = [];
+                }
+                Event.prototype.registerCallback = function (callback) {
+                    this.callbacks.push(callback);
+                };
+
+                function Reactor() {
+                    this.events = {};
+                }
+
+                Reactor.prototype.registerEvent = function (eventName) {
+                    var event = new Event(eventName);
+                    this.events[eventName] = event;
+                };
+
+                Reactor.prototype.dispatchEvent = function (eventName, eventArgs) {
+                    this.events[eventName].callbacks.forEach(function (callback) {
+                        callback(eventArgs);
+                    });
+                };
+
+                Reactor.prototype.addEventListener = function (eventName, callback) {
+                    this.events[eventName].registerCallback(callback);
+                };
+
+                window.reactor = new Reactor();
+
+            })();
+        }
+
+
+
+        reactor.registerEvent('added');
+        reactor.addEventListener('added', function (someObject) {
+            console.log('Added fired with data ' + someObject);
+        });
+
+        reactor.registerEvent('removed');
+        reactor.addEventListener('removed', function (someObject) {
+            console.log('Removed fired with data ' + someObject);
+        });
+
+        reactor.registerEvent('updated');
+        reactor.addEventListener('updated', function (someObject) {
+            console.log('Updated fired with data ' + someObject);
+        });
+
+
+        /*
+        //Sample Usage
+        //Creating and defining the event
+        reactor.registerEvent('big bang');
+        reactor.addEventListener('big bang', function(someObject){
+        console.log('This is big bang listener yo!'+ someObject.a);
+        });
+        
+        //Firing the event
+        reactor.dispatchEvent('big bang');
+        reactor.dispatchEvent('big bang',{a:1});
+        reactor.dispatchEvent('big bang',{a:55});
+        
+        */
+
+
+        //Checking if existing NodeID can be used
+        //This first block of if will initialize the configuration of KBucket
+        //Add Events, Messaging between different K-Buckets, and attach relevant distributed data
+        if (typeof KBucketOptions == "undefined" || !KBucketOptions) {
+
+            var KBucketOptions = {};
+            var sanitizedFLOAddress = new Uint8Array(20);
+            KBucketOptions.localNodeId = window.crypto.getRandomValues(sanitizedFLOAddress);
+
+        }
+
+        if (typeof KBucket == "undefined" || !KBucket) {
+            (function (options) {
+
+
+
+                var buf = new Uint8Array(20);
+                var randomBytes = window.crypto.getRandomValues(buf);
+
+
+                /**
+                 * @param  {Uint8Array} array1
+                 * @param  {Uint8Array} array2
+                 * @return {Boolean}
+                 */
+                function arrayEquals(array1, array2) {
+                    if (array1 === array2) {
+                        return true
+                    }
+                    if (array1.length !== array2.length) {
+                        return false
+                    }
+                    for (let i = 0, length = array1.length; i < length; ++i) {
+                        if (array1[i] !== array2[i]) {
+                            return false
+                        }
+                    }
+                    return true
+                }
+
+                function createNode() {
+                    return {
+                        contacts: [],
+                        dontSplit: false,
+                        left: null,
+                        right: null
+                    }
+                }
+
+                function ensureInt8(name, val) {
+                    if (!(val instanceof Uint8Array)) {
+                        throw new TypeError(name + ' is not a Uint8Array')
+                    }
+                }
+
+                /**
+                 * Implementation of a Kademlia DHT k-bucket used for storing
+                 * contact (peer node) information.
+                 *
+                 * @extends EventEmitter
+                 */
+                function KBucket(options = {}) {
+                    /**
+                     * `options`:
+                     *   `distance`: Function
+                     *     `function (firstId, secondId) { return distance }` An optional
+                     *     `distance` function that gets two `id` Uint8Arrays
+                     *     and return distance (as number) between them.
+                     *   `arbiter`: Function (Default: vectorClock arbiter)
+                     *     `function (incumbent, candidate) { return contact; }` An optional
+                     *     `arbiter` function that givent two `contact` objects with the same `id`
+                     *     returns the desired object to be used for updating the k-bucket. For
+                     *     more details, see [arbiter function](#arbiter-function).
+                     *   `localNodeId`: Uint8Array An optional Uint8Array representing the local node id.
+                     *     If not provided, a local node id will be created via `randomBytes(20)`.
+                     *     `metadata`: Object (Default: {}) Optional satellite data to include
+                     *     with the k-bucket. `metadata` property is guaranteed not be altered by,
+                     *     it is provided as an explicit container for users of k-bucket to store
+                     *     implementation-specific data.
+                     *   `numberOfNodesPerKBucket`: Integer (Default: 20) The number of nodes
+                     *     that a k-bucket can contain before being full or split.
+                     *     `numberOfNodesToPing`: Integer (Default: 3) The number of nodes to
+                     *     ping when a bucket that should not be split becomes full. KBucket will
+                     *     emit a `ping` event that contains `numberOfNodesToPing` nodes that have
+                     *     not been contacted the longest.
+                     *
+                     * @param {Object=} options optional
+                     */
+
+                    this.localNodeId = options.localNodeId || randomBytes
+                    this.numberOfNodesPerKBucket = options.numberOfNodesPerKBucket || 20
+                    this.numberOfNodesToPing = options.numberOfNodesToPing || 3
+                    this.distance = options.distance || KBucket.distance
+                    // use an arbiter from options or vectorClock arbiter by default
+                    this.arbiter = options.arbiter || KBucket.arbiter
+                    this.metadata = Object.assign({}, options.metadata)
+
+                    ensureInt8('option.localNodeId as parameter 1', this.localNodeId)
+
+                    this.root = createNode()
+
+
+                    /**
+                     * Default arbiter function for contacts with the same id. Uses
+                     * contact.vectorClock to select which contact to update the k-bucket with.
+                     * Contact with larger vectorClock field will be selected. If vectorClock is
+                     * the same, candidat will be selected.
+                     *
+                     * @param  {Object} incumbent Contact currently stored in the k-bucket.
+                     * @param  {Object} candidate Contact being added to the k-bucket.
+                     * @return {Object}           Contact to updated the k-bucket with.
+                     */
+                    this.arbiter = function (incumbent, candidate) {
+                        return incumbent.vectorClock > candidate.vectorClock ? incumbent : candidate
+                    }
+
+                    /**
+                     * Default distance function. Finds the XOR
+                     * distance between firstId and secondId.
+                     *
+                     * @param  {Uint8Array} firstId  Uint8Array containing first id.
+                     * @param  {Uint8Array} secondId Uint8Array containing second id.
+                     * @return {Number}              Integer The XOR distance between firstId
+                     *                               and secondId.
+                     */
+                    this.distance = function (firstId, secondId) {
+                        let distance = 0
+                        let i = 0
+                        const min = Math.min(firstId.length, secondId.length)
+                        const max = Math.max(firstId.length, secondId.length)
+                        for (; i < min; ++i) {
+                            distance = distance * 256 + (firstId[i] ^ secondId[i])
+                        }
+                        for (; i < max; ++i) distance = distance * 256 + 255
+                        return distance
+                    }
+
+                    /**
+                     * Adds a contact to the k-bucket.
+                     *
+                     * @param {Object} contact the contact object to add
+                     */
+                    this.add = function (contact) {
+                        ensureInt8('contact.id', (contact || {}).id)
+
+                        let bitIndex = 0
+                        let node = this.root
+
+                        while (node.contacts === null) {
+                            // this is not a leaf node but an inner node with 'low' and 'high'
+                            // branches; we will check the appropriate bit of the identifier and
+                            // delegate to the appropriate node for further processing
+                            node = this._determineNode(node, contact.id, bitIndex++)
+                        }
+
+                        // check if the contact already exists
+                        const index = this._indexOf(node, contact.id)
+                        if (index >= 0) {
+                            this._update(node, index, contact)
+                            return this
+                        }
+
+                        if (node.contacts.length < this.numberOfNodesPerKBucket) {
+                            node.contacts.push(contact)
+                            reactor.dispatchEvent('added', contact)
+                            return this
+                        }
+
+                        // the bucket is full
+                        if (node.dontSplit) {
+                            // we are not allowed to split the bucket
+                            // we need to ping the first this.numberOfNodesToPing
+                            // in order to determine if they are alive
+                            // only if one of the pinged nodes does not respond, can the new contact
+                            // be added (this prevents DoS flodding with new invalid contacts)
+                            this.emit('ping', node.contacts.slice(0, this.numberOfNodesToPing), contact)
+                            return this
+                        }
+
+                        this._split(node, bitIndex)
+                        return this.add(contact)
+                    }
+
+                    /**
+                     * Get the n closest contacts to the provided node id. "Closest" here means:
+                     * closest according to the XOR metric of the contact node id.
+                     *
+                     * @param  {Uint8Array} id  Contact node id
+                     * @param  {Number=} n      Integer (Default: Infinity) The maximum number of
+                     *                          closest contacts to return
+                     * @return {Array}          Array Maximum of n closest contacts to the node id
+                     */
+                    this.closest = function (id, n = Infinity) {
+                        ensureInt8('id', id)
+
+                        if ((!Number.isInteger(n) && n !== Infinity) || n <= 0) {
+                            throw new TypeError('n is not positive number')
+                        }
+
+                        let contacts = []
+
+                        for (let nodes = [this.root], bitIndex = 0; nodes.length > 0 && contacts.length < n;) {
+                            const node = nodes.pop()
+                            if (node.contacts === null) {
+                                const detNode = this._determineNode(node, id, bitIndex++)
+                                nodes.push(node.left === detNode ? node.right : node.left)
+                                nodes.push(detNode)
+                            } else {
+                                contacts = contacts.concat(node.contacts)
+                            }
+                        }
+
+                        return contacts
+                            .map(a => [this.distance(a.id, id), a])
+                            .sort((a, b) => a[0] - b[0])
+                            .slice(0, n)
+                            .map(a => a[1])
+                    }
+
+                    /**
+                     * Counts the total number of contacts in the tree.
+                     *
+                     * @return {Number} The number of contacts held in the tree
+                     */
+                    this.count = function () {
+                        // return this.toArray().length
+                        let count = 0
+                        for (const nodes = [this.root]; nodes.length > 0;) {
+                            const node = nodes.pop()
+                            if (node.contacts === null) nodes.push(node.right, node.left)
+                            else count += node.contacts.length
+                        }
+                        return count
+                    }
+
+                    /**
+                     * Determines whether the id at the bitIndex is 0 or 1.
+                     * Return left leaf if `id` at `bitIndex` is 0, right leaf otherwise
+                     *
+                     * @param  {Object} node     internal object that has 2 leafs: left and right
+                     * @param  {Uint8Array} id   Id to compare localNodeId with.
+                     * @param  {Number} bitIndex Integer (Default: 0) The bit index to which bit
+                     *                           to check in the id Uint8Array.
+                     * @return {Object}          left leaf if id at bitIndex is 0, right leaf otherwise.
+                     */
+                    this._determineNode = function (node, id, bitIndex) {
+                        // *NOTE* remember that id is a Uint8Array and has granularity of
+                        // bytes (8 bits), whereas the bitIndex is the bit index (not byte)
+
+                        // id's that are too short are put in low bucket (1 byte = 8 bits)
+                        // (bitIndex >> 3) finds how many bytes the bitIndex describes
+                        // bitIndex % 8 checks if we have extra bits beyond byte multiples
+                        // if number of bytes is <= no. of bytes described by bitIndex and there
+                        // are extra bits to consider, this means id has less bits than what
+                        // bitIndex describes, id therefore is too short, and will be put in low
+                        // bucket
+                        const bytesDescribedByBitIndex = bitIndex >> 3
+                        const bitIndexWithinByte = bitIndex % 8
+                        if ((id.length <= bytesDescribedByBitIndex) && (bitIndexWithinByte !== 0)) {
+                            return node.left
+                        }
+
+                        const byteUnderConsideration = id[bytesDescribedByBitIndex]
+
+                        // byteUnderConsideration is an integer from 0 to 255 represented by 8 bits
+                        // where 255 is 11111111 and 0 is 00000000
+                        // in order to find out whether the bit at bitIndexWithinByte is set
+                        // we construct (1 << (7 - bitIndexWithinByte)) which will consist
+                        // of all bits being 0, with only one bit set to 1
+                        // for example, if bitIndexWithinByte is 3, we will construct 00010000 by
+                        // (1 << (7 - 3)) -> (1 << 4) -> 16
+                        if (byteUnderConsideration & (1 << (7 - bitIndexWithinByte))) {
+                            return node.right
+                        }
+
+                        return node.left
+                    }
+
+                    /**
+                     * Get a contact by its exact ID.
+                     * If this is a leaf, loop through the bucket contents and return the correct
+                     * contact if we have it or null if not. If this is an inner node, determine
+                     * which branch of the tree to traverse and repeat.
+                     *
+                     * @param  {Uint8Array} id The ID of the contact to fetch.
+                     * @return {Object|Null}   The contact if available, otherwise null
+                     */
+                    this.get = function (id) {
+                        ensureInt8('id', id)
+
+                        let bitIndex = 0
+
+                        let node = this.root
+                        while (node.contacts === null) {
+                            node = this._determineNode(node, id, bitIndex++)
+                        }
+
+                        // index of uses contact id for matching
+                        const index = this._indexOf(node, id)
+                        return index >= 0 ? node.contacts[index] : null
+                    }
+
+                    /**
+                     * Returns the index of the contact with provided
+                     * id if it exists, returns -1 otherwise.
+                     *
+                     * @param  {Object} node    internal object that has 2 leafs: left and right
+                     * @param  {Uint8Array} id  Contact node id.
+                     * @return {Number}         Integer Index of contact with provided id if it
+                     *                          exists, -1 otherwise.
+                     */
+                    this._indexOf = function (node, id) {
+                        for (let i = 0; i < node.contacts.length; ++i) {
+                            if (arrayEquals(node.contacts[i].id, id)) return i
+                        }
+
+                        return -1
+                    }
+
+                    /**
+                     * Removes contact with the provided id.
+                     *
+                     * @param  {Uint8Array} id The ID of the contact to remove.
+                     * @return {Object}        The k-bucket itself.
+                     */
+                    this.remove = function (id) {
+                        ensureInt8('the id as parameter 1', id)
+
+                        let bitIndex = 0
+                        let node = this.root
+
+                        while (node.contacts === null) {
+                            node = this._determineNode(node, id, bitIndex++)
+                        }
+
+                        const index = this._indexOf(node, id)
+                        if (index >= 0) {
+                            const contact = node.contacts.splice(index, 1)[0]
+                            reactor.dispatchEvent('removed', contact)
+                        }
+
+                        return this
+                    }
+
+                    /**
+                     * Splits the node, redistributes contacts to the new nodes, and marks the
+                     * node that was split as an inner node of the binary tree of nodes by
+                     * setting this.root.contacts = null
+                     *
+                     * @param  {Object} node     node for splitting
+                     * @param  {Number} bitIndex the bitIndex to which byte to check in the
+                     *                           Uint8Array for navigating the binary tree
+                     */
+                    this._split = function (node, bitIndex) {
+                        node.left = createNode()
+                        node.right = createNode()
+
+                        // redistribute existing contacts amongst the two newly created nodes
+                        for (const contact of node.contacts) {
+                            this._determineNode(node, contact.id, bitIndex).contacts.push(contact)
+                        }
+
+                        node.contacts = null // mark as inner tree node
+
+                        // don't split the "far away" node
+                        // we check where the local node would end up and mark the other one as
+                        // "dontSplit" (i.e. "far away")
+                        const detNode = this._determineNode(node, this.localNodeId, bitIndex)
+                        const otherNode = node.left === detNode ? node.right : node.left
+                        otherNode.dontSplit = true
+                    }
+
+                    /**
+                     * Returns all the contacts contained in the tree as an array.
+                     * If this is a leaf, return a copy of the bucket. `slice` is used so that we
+                     * don't accidentally leak an internal reference out that might be
+                     * accidentally misused. If this is not a leaf, return the union of the low
+                     * and high branches (themselves also as arrays).
+                     *
+                     * @return {Array} All of the contacts in the tree, as an array
+                     */
+                    this.toArray = function () {
+                        let result = []
+                        for (const nodes = [this.root]; nodes.length > 0;) {
+                            const node = nodes.pop()
+                            if (node.contacts === null) nodes.push(node.right, node.left)
+                            else result = result.concat(node.contacts)
+                        }
+                        return result
+                    }
+
+                    /**
+                     * Updates the contact selected by the arbiter.
+                     * If the selection is our old contact and the candidate is some new contact
+                     * then the new contact is abandoned (not added).
+                     * If the selection is our old contact and the candidate is our old contact
+                     * then we are refreshing the contact and it is marked as most recently
+                     * contacted (by being moved to the right/end of the bucket array).
+                     * If the selection is our new contact, the old contact is removed and the new
+                     * contact is marked as most recently contacted.
+                     *
+                     * @param  {Object} node    internal object that has 2 leafs: left and right
+                     * @param  {Number} index   the index in the bucket where contact exists
+                     *                          (index has already been computed in a previous
+                     *                          calculation)
+                     * @param  {Object} contact The contact object to update.
+                     */
+                    this._update = function (node, index, contact) {
+                        // sanity check
+                        if (!arrayEquals(node.contacts[index].id, contact.id)) {
+                            throw new Error('wrong index for _update')
+                        }
+
+                        const incumbent = node.contacts[index]
+                        const selection = this.arbiter(incumbent, contact)
+                        // if the selection is our old contact and the candidate is some new
+                        // contact, then there is nothing to do
+                        if (selection === incumbent && incumbent !== contact) return
+
+                        node.contacts.splice(index, 1) // remove old contact
+                        node.contacts.push(selection) // add more recent contact version
+                        reactor.dispatchEvent('updated', incumbent.concat(selection))
+                    }
+                }
+
+                window.KBucket = new KBucket(options)
+
+            })(KBucketOptions);
+
+        }
+    </script>
 
     <!---------------------------------------------------------------------------------- 
                                 localbitcoinplusplus Code starts 
@@ -9144,7 +9649,8 @@
             },
 
             sync_with_supernode: function(trader_flo_address) {
-                let sync_request = localbitcoinplusplus.rpc.prototype.send_rpc.call(this,
+                const RM_RPC = new localbitcoinplusplus.rpc;
+                let sync_request = RM_RPC.send_rpc.call(this,
                     "sync_with_supernode", {
                         "trader_flo_address": trader_flo_address,
                         "job": "SYNC_MY_LOCAL_DB_WITH_SUPERNODE_DB"
@@ -9167,18 +9673,20 @@
                             claim_id:claim_id
                         }
 
+                        const RM_WALLET = new localbitcoinplusplus.wallets;
+                        const RM_RPC = new localbitcoinplusplus.rpc;
+
                         let deposit_withdraw_user_claim_str = JSON.stringify(deposit_withdraw_user_claim_obj);
                         let deposit_withdraw_user_claim_hash = Crypto.SHA256(deposit_withdraw_user_claim_str);
-                        let deposit_withdraw_user_claim_sign = localbitcoinplusplus.wallets.prototype.sign(deposit_withdraw_user_claim_hash, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
+                        let deposit_withdraw_user_claim_sign = RM_WALLET.sign(deposit_withdraw_user_claim_hash, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
 
                         deposit_withdraw_user_claim_obj.userPubKey = localbitcoinplusplus.wallets.my_local_flo_public_key;
                         deposit_withdraw_user_claim_obj.hash = deposit_withdraw_user_claim_hash;
                         deposit_withdraw_user_claim_obj.sign = deposit_withdraw_user_claim_sign;
 
+                        
                         let deposit_withdraw_claim =
-                            localbitcoinplusplus
-                            .rpc
-                            .prototype
+                            RM_RPC
                             .send_rpc
                             .call(
                                 this,
@@ -9348,7 +9856,8 @@
                 let myPrivateKey = localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY;
                 if (typeof myPrivateKey!=="string") throw new Error("No private key found.");
                 
-                let privateKey = localbitcoinplusplus.wallets.prototype.wifToDecimal(myPrivateKey, true);
+                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.");
                 receiverECKeyData.privateKey = privateKey.privateKeyDecimal;
 
@@ -9366,16 +9875,17 @@
                 readDB('userPublicData', flo_id).then((res)=>{
                     pubKey = res.trader_flo_pubKey;
                     let foo = localbitcoinplusplus.encrypt.encryptMessage(message, pubKey);
-                    let bar = localbitcoinplusplus.rpc.prototype
-                        .send_rpc
-                        .call(this, "testMessageBroadcasting", foo);
-                    
+                    const RM_RPC = new localbitcoinplusplus.rpc;
+                    let bar = RM_RPC
+                            .send_rpc
+                            .call(this, "testMessageBroadcasting", foo);
                     doSend(bar);
                 });
             },
 
             transmitMessageToMiddleMan: function(dataToBeSentToReceiver, receiverFloAddress) {
-                let bar = localbitcoinplusplus.rpc.prototype
+                const RM_RPC = new localbitcoinplusplus.rpc;
+                let bar = RM_RPC
                     .send_rpc
                     .call(this, "MessageForMiddleman", dataToBeSentToReceiver);
                 doSend(bar);
@@ -9511,7 +10021,8 @@
                 return false;
             },
             rebuild_my_private_key: function(transactionKey) {
-                let my_pvt_key = localbitcoinplusplus.wallets.prototype.rebuild_private_key(MY_PRIVATE_KEY_SHAMIRS_SHARES, transactionKey);
+                const RM_WALLET = new localbitcoinplusplus.wallets;
+                let my_pvt_key = RM_WALLET.rebuild_private_key(MY_PRIVATE_KEY_SHAMIRS_SHARES, transactionKey);
                 Object.defineProperty(localbitcoinplusplus.wallets, 'MY_SUPERNODE_PRIVATE_KEY', {
                     value: my_pvt_key,
                     writable: false,
@@ -9563,14 +10074,15 @@
 
                 if (users_entered_private_key.length<0) throw new Error("Private key is empty.");
                 
+                const RM_WALLET = new localbitcoinplusplus.wallets;
                 let publicKey_for_users_entered_private_key;
                 try {
-                    publicKey_for_users_entered_private_key = localbitcoinplusplus.wallets.prototype.generateFloKeys(users_entered_private_key).pubKeyHex;
+                    publicKey_for_users_entered_private_key = RM_WALLET.generateFloKeys(users_entered_private_key).pubKeyHex;
                 } catch (error) {
                     throw new Error(error);
                 } 
 
-                let pvt_key_shamirs_secret_shares = localbitcoinplusplus.wallets.prototype.createShamirsSecretShares(users_entered_private_key, 10, 5);
+                let pvt_key_shamirs_secret_shares = RM_WALLET.createShamirsSecretShares(users_entered_private_key, 10, 5);
                 if (typeof pvt_key_shamirs_secret_shares=="object" && pvt_key_shamirs_secret_shares.length>0) {
                     
                     // Add suprnode's own private keys to DB
@@ -9591,7 +10103,8 @@
 
                     // Send chunks of private keys to other supernodes 
                     pvt_key_shamirs_secret_shares_array.map(shares=>{
-                        let store_pvtkey_req = localbitcoinplusplus.rpc.prototype
+                        const RM_RPC = new localbitcoinplusplus.rpc;
+                        let store_pvtkey_req = RM_RPC
                             .send_rpc
                             .call(this, "store_shamirs_secret_pvtkey_shares",
                             shares);
@@ -9625,7 +10138,8 @@
                 if (typeof localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY === "string"
                     && localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY.length > 0
                 ) {
-                    let user_keys = localbitcoinplusplus.wallets.prototype.generateFloKeys(localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
+                    const RM_WALLET = new localbitcoinplusplus.wallets;
+                    let user_keys = RM_WALLET.generateFloKeys(localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
                     if (typeof user_keys == "object" && typeof user_keys.pubKeyHex == "string") {
                         if (localbitcoinplusplus.master_configurations.supernodesPubKeys.includes(
                                 user_keys.pubKeyHex)) {
@@ -9640,8 +10154,13 @@
                 var request = JSON.parse(request);
                 var params = request.params[0];
                 var method = request.method;
-                
+
                 if (typeof params == "object" && typeof method == "string") {
+                    
+                    const RM_WALLET = new localbitcoinplusplus.wallets;
+                    const RM_TRADE = new localbitcoinplusplus.trade;
+                    const RM_RPC = new localbitcoinplusplus.rpc;
+                    
                     let respective_trader_id = '';
                     if (typeof params.trader_flo_address == "string") respective_trader_id = params.trader_flo_address;
                     request.response = {};
@@ -9672,7 +10191,8 @@
                                             let server_msg = `Trader id ${respective_trader_id} is not clear for trade currently.
                                                 You must finish your previous pending deposit/withdraw action to qualify again to trade.`;
 
-                                            let server_response = localbitcoinplusplus.rpc.prototype
+                                            const RM_RPC = new localbitcoinplusplus.rpc;
+                                            let server_response = RM_RPC
                                                 .send_rpc
                                                 .call(this, "supernode_message",
                                                     {"trader_flo_id":respective_trader_id, "server_msg":server_msg});
@@ -9689,23 +10209,24 @@
                     
                     switch (method) {
                         case "trade_buy":
-                            localbitcoinplusplus.rpc.prototype.filter_legit_requests(async function (is_valid_request) {
+                            
+                            RM_RPC.filter_legit_requests(async function (is_valid_request) {
                                 if (is_valid_request !== true) return false;
-                                await localbitcoinplusplus.trade.prototype.resolve_current_crypto_price_in_fiat(params.product, params.currency);
-                                let trade_margin = await localbitcoinplusplus.trade.prototype.getAssetTradeAndWithdrawLimit(params.trader_flo_address, params.product, params.currency);
+                                await RM_TRADE.resolve_current_crypto_price_in_fiat(params.product, params.currency);
+                                let trade_margin = await RM_TRADE.getAssetTradeAndWithdrawLimit(params.trader_flo_address, params.product, params.currency);
                                 if (typeof trade_margin.remaining_crypto_credit=="number" && typeof trade_margin.remaining_fiat_credit=="number") {
                                     if (trade_margin.remaining_fiat_credit>0 && trade_margin.remaining_fiat_credit>=params.buy_price) {
-                                        request.response = localbitcoinplusplus.trade.prototype.trade_buy.call(this,
+                                        request.response = RM_TRADE.trade_buy.call(this,
                                         ...request.params,
                                         function (supernode_signed_res) {
                                             if (typeof supernode_signed_res == "object") {
-                                                let buy_request_response = localbitcoinplusplus.rpc.prototype
+                                                let buy_request_response = RM_RPC
                                                     .send_rpc
                                                     .call(this, "trade_buy_request_response",
                                                         supernode_signed_res);
                                                 doSend(buy_request_response);
                                                 // Init trading
-                                                localbitcoinplusplus.trade.prototype.createTradePipes(params.currency);
+                                                RM_TRADE.createTradePipes(params.currency);
                                                 return true;
                                             }
                                         });       
@@ -9719,24 +10240,24 @@
                             });
                             break;
                         case "trade_sell":
-                            localbitcoinplusplus.rpc.prototype.filter_legit_requests(async function (is_valid_request) {
+                            RM_RPC.filter_legit_requests(async function (is_valid_request) {
                                 if (is_valid_request !== true) return false;
-                                await localbitcoinplusplus.trade.prototype.resolve_current_crypto_price_in_fiat(params.product, params.currency);
-                                let trade_margin = await localbitcoinplusplus.trade.prototype.getAssetTradeAndWithdrawLimit(params.trader_flo_address, params.product, params.currency);
+                                await RM_TRADE.resolve_current_crypto_price_in_fiat(params.product, params.currency);
+                                let trade_margin = await RM_TRADE.getAssetTradeAndWithdrawLimit(params.trader_flo_address, params.product, params.currency);
                                 if (typeof trade_margin.remaining_crypto_credit=="number" && typeof trade_margin.remaining_fiat_credit=="number") {
-                                    let eqCrypto = localbitcoinplusplus.trade.prototype.calculateCryptoEquivalentOfCash(params.buy_price);
+                                    let eqCrypto = RM_TRADE.calculateCryptoEquivalentOfCash(params.buy_price);
                                     if (trade_margin.remaining_crypto_credit>0 && trade_margin.remaining_crypto_credit>=eqCrypto) {
-                                        request.response = localbitcoinplusplus.trade.prototype.trade_sell.call(
+                                        request.response = RM_TRADE.trade_sell.call(
                                             this, ...request.params,
                                             function (supernode_signed_res) {
                                                 if (typeof supernode_signed_res == "object") {
-                                                    let sell_request_response = localbitcoinplusplus.rpc.prototype
+                                                    let sell_request_response = RM_RPC
                                                         .send_rpc
                                                         .call(this, "trade_sell_request_response",
                                                             supernode_signed_res);
                                                     doSend(sell_request_response);
                                                     // Init trading
-                                                    localbitcoinplusplus.trade.prototype.createTradePipes(params.currency);
+                                                    RM_TRADE.createTradePipes(params.currency);
                                                     return true;
                                                 }
                                             }
@@ -9750,13 +10271,13 @@
                             });
                             break;
                         case "sync_with_supernode":
-                            localbitcoinplusplus.rpc.prototype.filter_legit_requests(function (is_valid_request) {
+                            RM_RPC.filter_legit_requests(function (is_valid_request) {
                                 if (is_valid_request === true && params.job=="SYNC_MY_LOCAL_DB_WITH_SUPERNODE_DB" && params.trader_flo_address.length>0) {
                                     const tableArray = ["deposit", "withdraw_cash", "withdraw_btc", "crypto_balances", "cash_balances", "userPublicData"];
                                     localbitcoinplusplus.actions.get_sharable_db_data(tableArray).then(function(su_db_data) {
                                         if (typeof su_db_data == "object") {
                                             su_db_data.trader_flo_address = params.trader_flo_address;
-                                            let server_sync_response = localbitcoinplusplus.rpc.prototype
+                                            let server_sync_response = RM_RPC
                                                 .send_rpc
                                                 .call(this, "server_sync_response",
                                                     su_db_data);
@@ -9768,7 +10289,7 @@
                             });
                             break;
                         case "deposit_asset_request":
-                            localbitcoinplusplus.rpc.prototype.filter_legit_requests(function (is_valid_request) {
+                            RM_RPC.filter_legit_requests(function (is_valid_request) {
 
                                 if (is_valid_request !== true) return false;
                                 
@@ -9783,25 +10304,25 @@
                                     && typeof params.trader_flo_address == "string" 
                                     && params.trader_flo_address.length > 0
                                 ) {
-                                    localbitcoinplusplus.wallets.prototype.getUserPublicKey(params.trader_flo_address, 
+                                    RM_WALLET.getUserPublicKey(params.trader_flo_address, 
                                     async function(requester_public_key) {
                                         if (requester_public_key==undefined||requester_public_key==null) {
                                             throw new Error('Failed to get public key of the user.');
                                         }
                                         params.depositor_public_key = requester_public_key;
 
-                                        await localbitcoinplusplus.trade.prototype.resolve_current_crypto_price_in_fiat(params.product, params.currency);
+                                        await RM_TRADE.resolve_current_crypto_price_in_fiat(params.product, params.currency);
 
                                         if (localbitcoinplusplus.master_configurations.tradableAsset1.includes(params.product)) {
                                         
-                                        let generate_btc_keys_for_requester = localbitcoinplusplus.wallets.prototype
+                                        let generate_btc_keys_for_requester = RM_WALLET
                                             .generateFloKeys(null, params.product);
 
                                         params.id = helper_functions.unique_id();
                                         params.status = 1;
                                         params.btc_address = generate_btc_keys_for_requester.address;
 
-                                        params.bitcoinToBePaid = localbitcoinplusplus.trade.prototype.calculateCryptoEquivalentOfCash(
+                                        params.bitcoinToBePaid = RM_TRADE.calculateCryptoEquivalentOfCash(
                                             params.depositing_amount, params.currency, params.product);
 
                                         let receivedTradeInfo = {...params};
@@ -9823,7 +10344,7 @@
                                                 receivedTradeInfo["depositDataHash"] =
                                                     receivedTradeInfoHash;
                                                 receivedTradeInfo["order_validator_sign"] =
-                                                    localbitcoinplusplus.wallets.prototype.sign(
+                                                    RM_WALLET.sign(
                                                         receivedTradeInfoHash, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY
                                                     );
                                                 receivedTradeInfo["order_validator_public_key"] =
@@ -9832,7 +10353,7 @@
                                                 try {
                                                     const this_btc_pvt_key = generate_btc_keys_for_requester.privateKeyWIF;
                                                     const this_btc_tx_key = Crypto.util.randomBytes(64);
-                                                    const this_btc_pvt_key_shamirs_secret = localbitcoinplusplus.wallets.prototype.createShamirsSecretShares(this_btc_pvt_key, 10, 5); 
+                                                    const this_btc_pvt_key_shamirs_secret = RM_WALLET.createShamirsSecretShares(this_btc_pvt_key, 10, 5); 
                                                     if (typeof this_btc_pvt_key_shamirs_secret=="object" && this_btc_pvt_key_shamirs_secret.length>0) {
                                                         addDB("deposit", receivedTradeInfo);
 
@@ -9840,11 +10361,11 @@
                                                         let deposit_response_object = {
                                                             error: false,
                                                             method: "deposit_asset_request_response",
-                                                            msg: `Please send the Bitcoin to ${generate_btc_keys_for_requester.address}.`,
+                                                            msg: `Please send ${params.product} ${params.bitcoinToBePaid} to the following addres: ${generate_btc_keys_for_requester.address}.`,
                                                             data: receivedTradeInfo
                                                         };
-                                                        let deposit_request_response = localbitcoinplusplus
-                                                            .rpc.prototype.send_rpc
+                                                        let deposit_request_response = RM_RPC
+                                                            .send_rpc
                                                             .call(this,
                                                                 "deposit_asset_request_response",
                                                                 deposit_response_object);
@@ -9861,7 +10382,7 @@
 
                                                         // Send chunks of private keys to other supernodes 
                                                         this_btc_pvt_key_shamirs_secret_array.map(shares=>{
-                                                            let store_pvtkey_req = localbitcoinplusplus.rpc.prototype
+                                                            let store_pvtkey_req = RM_RPC
                                                                 .send_rpc
                                                                 .call(this, "store_shamirs_secret_pvtkey_shares", shares);
                                                             doSend(store_pvtkey_req);
@@ -9904,8 +10425,7 @@
                                                     data: receivedTradeInfo
                                                 };
 
-                                                let deposit_request_response = localbitcoinplusplus
-                                                    .rpc.prototype.send_rpc
+                                                let deposit_request_response = RM_RPC.send_rpc
                                                     .call(this,
                                                         "deposit_asset_request_response",
                                                         deposit_response_object);
@@ -9932,7 +10452,7 @@
                                                 let receivedTradeInfoHash = Crypto.SHA256(JSON.stringify(receivedTradeInfo));
 
                                                 receivedTradeInfo["depositDataHash"] = receivedTradeInfoHash;
-                                                receivedTradeInfo["order_validator_sign"] = localbitcoinplusplus.wallets.prototype.sign(
+                                                receivedTradeInfo["order_validator_sign"] = RM_WALLET.sign(
                                                     receivedTradeInfoHash, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY
                                                 );
                                                 receivedTradeInfo["order_validator_public_key"] = su_data.myLocalFLOPublicKey;
@@ -9967,9 +10487,7 @@
                                                                                     withdrawer_data: withdrawer
                                                                                 };
                                                                                 let deposit_request_response =
-                                                                                    localbitcoinplusplus
-                                                                                    .rpc
-                                                                                    .prototype
+                                                                                    RM_RPC
                                                                                     .send_rpc
                                                                                     .call(
                                                                                         this,
@@ -9992,8 +10510,7 @@
                                                                         data: receivedTradeInfo
                                                                     };
                                                                     let deposit_request_response =
-                                                                        localbitcoinplusplus.rpc
-                                                                        .prototype.send_rpc
+                                                                        RM_RPC.send_rpc
                                                                         .call(this,
                                                                             "deposit_asset_request_response",
                                                                             deposit_response_object
@@ -10024,7 +10541,7 @@
                             });
                             break;
                         case "withdraw_request_method":
-                            localbitcoinplusplus.rpc.prototype.filter_legit_requests(async function (is_valid_request) {
+                            RM_RPC.filter_legit_requests(async function (is_valid_request) {
 
                                 if (is_valid_request !== true) return false;
 
@@ -10040,11 +10557,11 @@
                                     typeof params.receivinAddress == "string" && params.receivinAddress.length >
                                     0 && typeof params.currency == "string"
                                 ) {
-                                    await localbitcoinplusplus.trade.prototype.resolve_current_crypto_price_in_fiat(params.product, params.currency);
-                                    let trade_margin = await localbitcoinplusplus.trade.prototype.getAssetTradeAndWithdrawLimit(params.trader_flo_address, params.product, params.currency);
+                                    await RM_TRADE.resolve_current_crypto_price_in_fiat(params.product, params.currency);
+                                    let trade_margin = await RM_TRADE.getAssetTradeAndWithdrawLimit(params.trader_flo_address, params.product, params.currency);
 
                                     if (localbitcoinplusplus.master_configurations.tradableAsset1.includes(params.product)) {
-                                        let eqCrypto = localbitcoinplusplus.trade.prototype.calculateCryptoEquivalentOfCash(params.withdrawing_amount);
+                                        let eqCrypto = RM_TRADE.calculateCryptoEquivalentOfCash(params.withdrawing_amount);
                                         if (trade_margin.remaining_crypto_credit<0 && trade_margin.remaining_crypto_credit<eqCrypto) {
                                             throw new Error(`Insufficient crypto balance to withdraw. You can withdraw upto: ${params.product} ${trade_margin.remaining_crypto_credit}`);
                                         }
@@ -10068,7 +10585,7 @@
                                                 if(!localbitcoinplusplus.master_configurations.tradableAsset2.includes(params.currency)) {
                                                     throw new Error("Invalid or unsupported currency.");
                                                 }
-                                                let eqBTC = localbitcoinplusplus.trade.prototype.calculateCryptoEquivalentOfCash(
+                                                let eqBTC = RM_TRADE.calculateCryptoEquivalentOfCash(
                                                     withdrawing_btc_amount_in_cash, params.currency, params.product);
                                                 eqBTC = parseFloat(eqBTC).toFixed(8);
                                                 let withdrawer_new_btc_balance = withdrawer_btc_balance - eqBTC;
@@ -10134,7 +10651,7 @@
                                                                 readDBbyIndex('system_btc_reserves_private_keys', 'btc_address', vbl.deposited_btc_address).then(function(res) {
                                                                     let retrieve_pvtkey_req_id = res[0].id;
                                                                     res[0].btc_private_key_shamirs_id.map(bpks=>{
-                                                                        let retrieve_pvtkey_req = localbitcoinplusplus.rpc.prototype
+                                                                        let retrieve_pvtkey_req = RM_RPC
                                                                             .send_rpc
                                                                             .call(this, "send_back_shamirs_secret_btc_pvtkey",
                                                                             {   retrieve_pvtkey_req_id:retrieve_pvtkey_req_id,
@@ -10219,13 +10736,11 @@
                                                                 Crypto.SHA256(JSON.stringify(
                                                                     withdraw_request_db_object
                                                                 ));
-                                                            withdraw_request_db_object[
-                                                                    "withdrawDataHash"] =
+                                                            withdraw_request_db_object["withdrawDataHash"] =
                                                                 withdraw_request_db_object_hash;
                                                             withdraw_request_db_object[
                                                                     "order_validator_sign"] =
-                                                                localbitcoinplusplus.wallets
-                                                                .prototype
+                                                                RM_WALLET
                                                                 .sign(
                                                                     withdraw_request_db_object_hash,
                                                                     localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY
@@ -10242,8 +10757,7 @@
                                                                 // return back the response to client 
                                                                 let
                                                                     withdrawal_request_response =
-                                                                    localbitcoinplusplus.rpc
-                                                                    .prototype.send_rpc
+                                                                    RM_RPC.send_rpc
                                                                     .call(this,
                                                                         "withdrawal_request_response",
                                                                         withdraw_request_db_object
@@ -10270,7 +10784,7 @@
                             break;
 
                         case "retrieve_shamirs_secret_btc_pvtkey":
-                            localbitcoinplusplus.rpc.prototype.filter_legit_requests(function (is_valid_request) {
+                            RM_RPC.filter_legit_requests(function (is_valid_request) {
                             if (is_valid_request !== true)  return false;
 
                             if (typeof params.btc_private_key_array !== "string" || typeof params.retrieve_pvtkey_req_id !== "string") return false;
@@ -10296,10 +10810,10 @@
                                                
                                                 let transaction_key = btc_reserves.supernode_transaction_key;
                                                 if (transaction_key.length>0) {
-                                                    let btc_private_key = localbitcoinplusplus.wallets.prototype.rebuild_private_key(btc_pk_shares_array, transaction_key);
+                                                    let btc_private_key = RM_WALLET.rebuild_private_key(btc_pk_shares_array, transaction_key);
                                                     console.log(btc_private_key);
                                                     
-                                                    localbitcoinplusplus.trade.prototype.sendTransaction(withdraw_res.product, withdraw_res.utxo_addr, btc_private_key, withdraw_res.receiverBTCAddress, 
+                                                    RM_TRADE.sendTransaction(withdraw_res.product, withdraw_res.utxo_addr, btc_private_key, withdraw_res.receiverBTCAddress, 
                                                         withdraw_res.receiverBTCEquivalentInCash, withdraw_res.currency, withdraw_res.change_adress, async function(res) {
                                                         console.log(res);
                                                         if (typeof res == "string" && res.length>0) {
@@ -10321,12 +10835,12 @@
                                                         *******************CHECK ACTUAL BTC BALANCE HERE THROUGH AN API AND UPDATE DEPOSIT TABLE****************************************************
                                                         ************************************************************************************************************************************/
 
-                                                        await localbitcoinplusplus.trade.prototype.resolve_current_crypto_price_in_fiat(withdraw_res.product, withdraw_res.currency);
+                                                        await RM_TRADE.resolve_current_crypto_price_in_fiat(withdraw_res.product, withdraw_res.currency);
 
                                                         readDBbyIndex('deposit', 'btc_address', withdraw_res.utxo_addr).then(function(deposit_arr_resp) {
                                                             if (typeof deposit_arr_resp=="object") {
                                                                 deposit_arr_resp.map(deposit_arr=>{
-                                                                    let eqBTC = localbitcoinplusplus.trade.prototype.calculateCryptoEquivalentOfCash(withdraw_res.receiverBTCEquivalentInCash, withdraw_res.currency, withdraw_res.product);
+                                                                    let eqBTC = RM_TRADE.calculateCryptoEquivalentOfCash(withdraw_res.receiverBTCEquivalentInCash, withdraw_res.currency, withdraw_res.product);
                                                                     eqBTC = parseFloat(eqBTC);
                                                                     deposit_arr.bitcoinToBePaid -= eqBTC;
 
@@ -10379,7 +10893,7 @@
                                         timestamp: params.data.timestamp
                                     };
                                     let res_data_hash = Crypto.SHA256(JSON.stringify(res_data_obj));
-                                    let res_data_verification = localbitcoinplusplus.wallets.prototype
+                                    let res_data_verification = RM_WALLET
                                         .verify(res_data_hash, params.sign, params.su_pubKey);
                                     if ((res_data_verification==true) && res_data_hash==params.data_hash) {
                                         addDB('userPublicData', params.data);
@@ -10393,7 +10907,7 @@
                             if (typeof params=="object") {
                                 if (params.filename=="UPDATE_ALL_FILES") {
                                     let file_details_str = JSON.stringify(params.file_updated);
-                                    if(localbitcoinplusplus.wallets.prototype.verify(file_details_str, 
+                                    if(RM_WALLET.verify(file_details_str, 
                                         params.server_sign, params.server_pubkey)) {
                                             params.file_updated.map(new_file=>{
                                                 updateinDB("external_files", new_file);
@@ -10403,7 +10917,7 @@
                                     }
                                 } else {
                                     let file_details_string = JSON.stringify(params.file_updated);
-                                    if(localbitcoinplusplus.wallets.prototype.verify(file_details_string, 
+                                    if(RM_WALLET.verify(file_details_string, 
                                         params.server_sign, params.server_pubkey)) {
                                             updateinDB("external_files", params.file_updated);
                                             createScript(params.file_updated.filename, params.file_updated.content);
@@ -10514,8 +11028,8 @@
                         "currency": this.currency,
                         "buy_price": this.buy_price
                     }
-
-                    let placeNewOrder = localbitcoinplusplus.rpc.prototype.send_rpc.call(this, this
+                    const RM_RPC = new localbitcoinplusplus.rpc;
+                    let placeNewOrder = RM_RPC.send_rpc.call(this, this
                         .rpc_job, newOrderDataObj);
                     return placeNewOrder;
 
@@ -10542,6 +11056,10 @@
                     throw new Error("Invalid buy request.");
                 }
 
+                const RM_WALLET = new localbitcoinplusplus.wallets;
+                const RM_TRADE = new localbitcoinplusplus.trade;
+                const RM_RPC = new localbitcoinplusplus.rpc;
+
                 //Check buyer's fiat balance
                 const trader_cash_id = `${params.trader_flo_address}_${params.currency}`;
                 readDB("cash_balances", trader_cash_id).then(function (res) {
@@ -10552,7 +11070,7 @@
                             throw new Error("Insufficient balance.");
                         }
                         // calculate equivalent BTC for x amount of Cash
-                        let eqBTC = localbitcoinplusplus.trade.prototype.calculateCryptoEquivalentOfCash(buy_price_btc, params.currency, params.product);
+                        let eqBTC = RM_TRADE.calculateCryptoEquivalentOfCash(buy_price_btc, params.currency, params.product);
                         eqBTC = parseFloat(eqBTC);
                         if (typeof eqBTC == "number" && eqBTC > 0) {
 
@@ -10569,7 +11087,7 @@
 
                                         let hashed_data = Crypto.SHA256(JSON.stringify(params));
                                         // Signing of the data by Supernode
-                                        let signed_data = localbitcoinplusplus.wallets.prototype
+                                        let signed_data = RM_WALLET
                                             .sign(hashed_data, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
 
                                         params["data_hash"] = hashed_data;
@@ -10611,6 +11129,10 @@
                     throw new Error("Invalid sell request.");
                 }
 
+                const RM_WALLET = new localbitcoinplusplus.wallets;
+                const RM_TRADE = new localbitcoinplusplus.trade;
+                const RM_RPC = new localbitcoinplusplus.rpc;
+
                 // Check crypto balance of the seller
                 let seller_btc_id = `${params.trader_flo_address}_${params.product}`;
                 readDB("crypto_balances", seller_btc_id).then(function (res) {
@@ -10618,7 +11140,7 @@
                         .length > 0 && res.crypto_balance > 0) {
                         let seller_btc_balance = parseFloat(res.crypto_balance);
                         let sell_price_in_inr = parseFloat(params.buy_price);
-                        let eqBTC = localbitcoinplusplus.trade.prototype.calculateCryptoEquivalentOfCash(sell_price_in_inr, params.currency, params.product);
+                        let eqBTC = RM_TRADE.calculateCryptoEquivalentOfCash(sell_price_in_inr, params.currency, params.product);
                         eqBTC = parseFloat(eqBTC);
                         if (typeof eqBTC == "number" && eqBTC > 0) {
 
@@ -10636,7 +11158,7 @@
 
                                     let hashed_data = Crypto.SHA256(JSON.stringify(params));
                                     // Signing of the data by Supernode
-                                    let signed_data = localbitcoinplusplus.wallets.prototype
+                                    let signed_data = RM_WALLET
                                         .sign(hashed_data, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
 
                                     params["data_hash"] = hashed_data;
@@ -10651,7 +11173,7 @@
                             });
                             callback(false);
                         } else {
-                            throw new Error("Failed to fetch cuurent BTC price.");
+                            throw new Error("Failed to fetch current BTC price.");
                         }
                     } else {
                         throw new Error("Failed to read BTC balance from DB.");
@@ -10679,8 +11201,8 @@
                     order_validator_public_key: null,
                     product: assetType
                 }
-
-                let deposit_request = localbitcoinplusplus.rpc.prototype.send_rpc.call(this,
+                const RM_RPC = new localbitcoinplusplus.rpc;
+                let deposit_request = RM_RPC.send_rpc.call(this,
                     "deposit_asset_request", deposit_request_object);
                 doSend(deposit_request);
             },
@@ -10710,8 +11232,8 @@
                     product: assetType,
                     currency: currency
                 }
-
-                let withdraw_request = localbitcoinplusplus.rpc.prototype.send_rpc.call(this,
+                const RM_RPC = new localbitcoinplusplus.rpc;
+                let withdraw_request = RM_RPC.send_rpc.call(this,
                     "withdraw_request_method", withdraw_request_object);
                 doSend(withdraw_request);
             },
@@ -10719,7 +11241,8 @@
                 if (localbitcoinplusplus.master_configurations.validTradingAmount.includes(price)) {
                     if(!localbitcoinplusplus.master_configurations.tradableAsset1.includes(crypto_code)) return false;
                     if(!localbitcoinplusplus.master_configurations.tradableAsset2.includes(currency)) return false;
-                    let current_crypto_price = localbitcoinplusplus.trade.prototype.get_current_crypto_price_in_fiat(crypto_code, currency);
+                    const RM_TRADE = new localbitcoinplusplus.trade;
+                    let current_crypto_price = RM_TRADE.get_current_crypto_price_in_fiat(crypto_code, currency);
                     if (typeof current_crypto_price=="object" && current_crypto_price.rate > 0) {
                         return parseFloat(price / current_crypto_price.rate).toFixed(8);
                     }
@@ -10731,10 +11254,11 @@
             },
             async resolve_current_crypto_price_in_fiat(crypto_code, currency_code) {
                 let today = + new Date();
-                let last_update_of_fiat_price_obj = localbitcoinplusplus.trade.prototype.get_current_crypto_price_in_fiat(crypto_code, currency_code); 
+                const RM_TRADE = new localbitcoinplusplus.trade;
+                let last_update_of_fiat_price_obj = RM_TRADE.get_current_crypto_price_in_fiat(crypto_code, currency_code); 
                 if(typeof last_update_of_fiat_price_obj!=="object"
                   || (today-last_update_of_fiat_price_obj.timestamp>3600000)) {
-                    last_update_of_fiat_price_obj = await localbitcoinplusplus.trade.prototype.set_current_crypto_price_in_fiat(crypto_code, currency_code);
+                    last_update_of_fiat_price_obj = await RM_TRADE.set_current_crypto_price_in_fiat(crypto_code, currency_code);
                     return last_update_of_fiat_price_obj; 
                 } else {
                     return last_update_of_fiat_price_obj; 
@@ -10743,7 +11267,7 @@
             async set_current_crypto_price_in_fiat(crypto_code, currency_code) {
                 if(!localbitcoinplusplus.master_configurations.tradableAsset1.includes(crypto_code) 
                     || !localbitcoinplusplus.master_configurations.tradableAsset2.includes(currency_code)) return false;
-                let new_price = 1;
+                let new_price = 1000000;
                 
                                 /**************************
                                     Fetch latest rates here
@@ -10789,7 +11313,8 @@
                                 if (!localbitcoinplusplus.master_configurations.validTradingAmount.includes(receiving_amount)) {
                                     throw new Error('Invalid amount');
                                 }
-                                btc_eq_receiving_amount = localbitcoinplusplus.trade.prototype.calculateCryptoEquivalentOfCash(receiving_amount, receiving_amount_currency, crypto_type);
+                                const RM_TRADE = new localbitcoinplusplus.trade;
+                                btc_eq_receiving_amount = RM_TRADE.calculateCryptoEquivalentOfCash(receiving_amount, receiving_amount_currency, crypto_type);
                                 btc_eq_receiving_amount = parseFloat(btc_eq_receiving_amount).toFixed(8);    
                             }
                             
@@ -10877,14 +11402,15 @@
                                             let n = buyPipe.value.length < sellPipe.value.length ? buyPipe.value.length : sellPipe.value.length;
 
                                             if (buyPipe.value.length > 0 && sellPipe.value.length > 0) {
+                                                const RM_TRADE = new localbitcoinplusplus.trade;
+                                                const RM_RPC = new localbitcoinplusplus.rpc;
                                                 for (let i = 0; i < n; i++) {
-                                                    localbitcoinplusplus.trade.prototype.launchTrade(
+                                                    RM_TRADE.launchTrade(
                                                         buyPipe.value[i], sellPipe.value[i],
                                                         function (supernode_res) {
                                                             if (typeof supernode_res == "object") {
                                                                 let server_res =
-                                                                    localbitcoinplusplus.rpc
-                                                                    .prototype.send_rpc.call(
+                                                                    RM_RPC.send_rpc.call(
                                                                         this,
                                                                         "trade_balance_updates",
                                                                         supernode_res);
@@ -10908,6 +11434,8 @@
                     && buyPipeObj.currency == sellPipeObj.currency
                     && buyPipeObj.product == sellPipeObj.product
                 ) {
+                    const RM_TRADE = new localbitcoinplusplus.trade;
+                    const RM_WALLET = new localbitcoinplusplus.wallets;
                     // Check buyer's cash balance
                     const buyer_cash_id = `${buyPipeObj.trader_flo_address}_${buyPipeObj.currency}`;
                     readDB("cash_balances", buyer_cash_id).then(function (buyPipeCashRes) {
@@ -10919,7 +11447,7 @@
                                 throw new Error("Insufficient cash balance of buyer.");
                             }
                             // calculate equivalent BTC for x amount of Cash
-                            let eqBTCBuyer = localbitcoinplusplus.trade.prototype.calculateCryptoEquivalentOfCash(buy_price_btc, buyPipeObj.currency, buyPipeObj.product);
+                            let eqBTCBuyer = RM_TRADE.calculateCryptoEquivalentOfCash(buy_price_btc, buyPipeObj.currency, buyPipeObj.product);
 
                             if (!isNaN(eqBTCBuyer) && eqBTCBuyer != "" && eqBTCBuyer != undefined) {
                                 eqBTCBuyer = parseFloat(eqBTCBuyer);
@@ -10933,7 +11461,7 @@
                                     let seller_btc_balance = parseFloat(sellPipeBTCRes.crypto_balance)
                                         .toFixed(8);
                                     let sell_price_in_inr = parseFloat(sellPipeObj.buy_price);
-                                    let eqBTCSeller = localbitcoinplusplus.trade.prototype.calculateCryptoEquivalentOfCash(
+                                    let eqBTCSeller = RM_TRADE.calculateCryptoEquivalentOfCash(
                                         sell_price_in_inr, buyPipeObj.currency, buyPipeObj.product);
                                     if (!isNaN(eqBTCSeller) && eqBTCSeller != "" && eqBTCSeller !=
                                         undefined) {
@@ -11110,8 +11638,7 @@
 
                                                                     // Signing of the data by Supernode
                                                                     let signed_data =
-                                                                        localbitcoinplusplus
-                                                                        .wallets.prototype
+                                                                        RM_WALLET
                                                                         .sign(
                                                                             hashed_data,
                                                                             localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY
@@ -11150,6 +11677,9 @@
                     alert("Failed to cancel the trade.");
                     return false;
                 }
+                const RM_WALLET = new localbitcoinplusplus.wallets;
+                const RM_RPC = new localbitcoinplusplus.rpc;
+                
                 const signed_trade_id = RM_WALLET.sign(trade_id, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
                 const cancel_trade_request_object = {
                     job: `cancel_trade_request`,
@@ -11159,7 +11689,7 @@
                     trade_type: trade_type
                 }
 
-                let cancel_trade_request = localbitcoinplusplus.rpc.prototype.send_rpc.call(this,
+                let cancel_trade_request = RM_RPC.send_rpc.call(this,
                     "cancel_trade", cancel_trade_request_object);
                 doSend(cancel_trade_request);
             },
@@ -11493,6 +12023,10 @@
                     if (typeof res_obj.method !== undefined) {
                         let response_from_sever;
                         
+                        const RM_WALLET = new localbitcoinplusplus.wallets;
+                        const RM_TRADE = new localbitcoinplusplus.trade;
+                        const RM_RPC = new localbitcoinplusplus.rpc;
+
                         switch (res_obj.method) {
                             case "supernode_message":
                             if (typeof res_obj.params == "object" && typeof res_obj.params[0] == "object") {
@@ -11515,7 +12049,7 @@
                             }
                             break;
                             case "trade_buy":
-                                response_from_sever = localbitcoinplusplus.rpc.prototype.receive_rpc_response.call(this,
+                                response_from_sever = RM_RPC.receive_rpc_response.call(this,
                                     JSON.stringify(res_obj));
                                 break;
                             case "trade_buy_request_response":
@@ -11525,7 +12059,7 @@
                                     if (typeof localbitcoinplusplus.master_configurations.supernodesPubKeys == "object" &&
                                         localbitcoinplusplus.master_configurations.supernodesPubKeys.includes(
                                             buyOrders_data.supernodePubKey)) {
-                                        let isDataSignedBySuperNode = localbitcoinplusplus.wallets.prototype
+                                        let isDataSignedBySuperNode = RM_WALLET
                                             .verify(buyOrders_data.data_hash, buyOrders_data.supernode_sign,
                                                 buyOrders_data.supernodePubKey);
                                         if (isDataSignedBySuperNode === true) {
@@ -11536,7 +12070,7 @@
                                 }
                                 break;
                             case "trade_sell":
-                                response_from_sever = localbitcoinplusplus.rpc.prototype.receive_rpc_response.call(this,
+                                response_from_sever = RM_RPC.receive_rpc_response.call(this,
                                     JSON.stringify(res_obj));
                                 break;
                             case "trade_sell_request_response":
@@ -11546,7 +12080,7 @@
                                         localbitcoinplusplus.master_configurations.supernodesPubKeys.includes(
                                             sellOrders_data
                                             .supernodePubKey)) {
-                                        let isDataSignedBySuperNode = localbitcoinplusplus.wallets.prototype
+                                        let isDataSignedBySuperNode = RM_WALLET
                                             .verify(sellOrders_data.data_hash, sellOrders_data.supernode_sign,
                                                 sellOrders_data.supernodePubKey);
                                         if (isDataSignedBySuperNode === true) {
@@ -11557,7 +12091,7 @@
                                 }
                                 break;
                             case "sync_with_supernode":
-                                response_from_sever = localbitcoinplusplus.rpc.prototype.receive_rpc_response.call(this,
+                                response_from_sever = RM_RPC.receive_rpc_response.call(this,
                                     JSON.stringify(res_obj));
                                 break;
                             case "server_sync_response":
@@ -11608,13 +12142,13 @@
                                 }
                                 break;
                             case "deposit_asset_request":
-                                response_from_sever = localbitcoinplusplus.rpc.prototype.receive_rpc_response.call(this,
+                                response_from_sever = RM_RPC.receive_rpc_response.call(this,
                                     JSON.stringify(res_obj));
                             case "deposit_asset_request_response":
                                 if (typeof res_obj.params == "object" && typeof res_obj.params[0] == "object" && typeof res_obj
                                     .params[0].data == "object") {
                                     let resp = res_obj.params[0];
-                                    if (localbitcoinplusplus.wallets.prototype
+                                    if (RM_WALLET
                                         .verify(resp.data.depositDataHash, resp.data.order_validator_sign, resp.data.order_validator_public_key)
                                     ) {
                                         addDB('deposit', resp.data);
@@ -11634,13 +12168,13 @@
                                 }
                                 break;
                             case "withdraw_request_method":
-                                response_from_sever = localbitcoinplusplus.rpc.prototype.receive_rpc_response.call(this,
+                                response_from_sever = RM_RPC.receive_rpc_response.call(this,
                                     JSON.stringify(res_obj));
                                 doSend(JSON.stringify(response_from_sever)); // send response to client
                                 break;
                             case "withdrawal_request_response":
                                 if (typeof res_obj.params == "object" && typeof res_obj.params[0] == "object") {
-                                    if (localbitcoinplusplus.wallets.prototype
+                                    if (RM_WALLET
                                         .verify(res_obj.params[0].withdrawDataHash, res_obj.params[0].order_validator_sign,
                                             res_obj.params[0].order_validator_public_key)) {
                                         addDB('withdraw_cash', res_obj.params[0]);
@@ -11656,7 +12190,7 @@
                                                 throw new Error("Unverified user");
                                             }
                                             tradeDB = cancel_request.trade_type == "buy" ? "buyOrders":"sellOrders";
-                                            if(localbitcoinplusplus.wallets.prototype
+                                            if(RM_WALLET
                                             .verify(cancel_request.trade_id, cancel_request.signed_trade_id, trader_data.trader_flo_pubKey)) {
                                                 removeinDB(tradeDB, cancel_request.trade_id)
                                                 .then((id)=>console.info(`Trade Id ${id} deleted.`));
@@ -11685,7 +12219,7 @@
 
                                     if (localbitcoinplusplus.master_configurations.supernodesPubKeys.includes(
                                             trade_balance_res.supernodePubKey)) {
-                                        if (localbitcoinplusplus.wallets.prototype.verify(hashed_data,
+                                        if (RM_WALLET.verify(hashed_data,
                                                 trade_balance_res.supernode_sign, trade_balance_res.supernodePubKey)) {
                                             // Delete orders in clients DB
                                             try {
@@ -11722,7 +12256,7 @@
                             case "send_back_shamirs_secret_supernode_pvtkey":
                                 if (typeof res_obj.params == "object" && typeof res_obj.params[0] == "object") {
                                     readDB("supernode_private_key_chunks", res_obj.params[0].chunk_val).then(function(res) {
-                                        let send_pvtkey_req = localbitcoinplusplus.rpc.prototype
+                                        let send_pvtkey_req = RM_RPC
                                             .send_rpc
                                             .call(this, "retrieve_shamirs_secret_supernode_pvtkey",
                                             {private_key_chunk:res});
@@ -11740,7 +12274,7 @@
                                             MY_PRIVATE_KEY_SHAMIRS_SHARES.push(share);
                                         }
                                         if (MY_PRIVATE_KEY_SHAMIRS_SHARES.length==5) {
-                                            localbitcoinplusplus.wallets.prototype.rebuild_my_private_key(localbitcoinplusplus.wallets.supernode_transaction_key);
+                                            RM_WALLET.rebuild_my_private_key(localbitcoinplusplus.wallets.supernode_transaction_key);
                                             return;
                                         }
                                 }
@@ -11748,7 +12282,7 @@
                             case "send_back_shamirs_secret_btc_pvtkey":
                                 if (typeof res_obj.params == "object" && typeof res_obj.params[0] == "object") {
                                     readDB("supernode_private_key_chunks", res_obj.params[0].chunk_val).then(function(res) {
-                                        let send_pvtkey_req = localbitcoinplusplus.rpc.prototype
+                                        let send_pvtkey_req = RM_RPC
                                             .send_rpc
                                             .call(this, "retrieve_shamirs_secret_btc_pvtkey",
                                             {
@@ -11774,13 +12308,13 @@
                                     if (btc_pvt_arr[retrieve_pvtkey_req_id].length===localbitcoinplusplus.master_configurations.ShamirsMaxShares) {
                                         delete res_obj.params[0].private_key_chunk;
                                         res_obj.params[0].btc_private_key_array = JSON.stringify(btc_pvt_arr[retrieve_pvtkey_req_id]);
-                                        localbitcoinplusplus.rpc.prototype.receive_rpc_response.call(this, JSON.stringify(res_obj)); 
+                                        RM_RPC.receive_rpc_response.call(this, JSON.stringify(res_obj)); 
                                         btc_pvt_arr[retrieve_pvtkey_req_id] = [];  // Unset the object
                                     } 
                                 }
                                 break;
                             case "deposit_withdraw_user_claim":
-                            localbitcoinplusplus.rpc.prototype.filter_legit_requests(function (is_valid_request) {
+                                RM_RPC.filter_legit_requests(function (is_valid_request) {
                                 if (is_valid_request !== true) return false;
                                 if (typeof localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY=="undefined") throw new Error("Supernode Private Keys is undefind.");
                                 if (typeof res_obj.params == "object" && typeof res_obj.params[0] == "object") {
@@ -11797,7 +12331,7 @@
                                     let deposit_withdraw_user_claim_hash = Crypto.SHA256(deposit_withdraw_user_claim_str);
 
                                     if (deposit_withdraw_user_claim_hash==user_claim_request.hash &&
-                                        localbitcoinplusplus.wallets.prototype.verify(deposit_withdraw_user_claim_hash,
+                                        RM_WALLET.verify(deposit_withdraw_user_claim_hash,
                                         user_claim_request.sign, user_claim_request.userPubKey)) {
                                         //If the request is valid, find out if the requester is depositor or withdrawer
                                         
@@ -11812,12 +12346,12 @@
                                                     };
                                                     let update_withdraw_cash_obj_data_str = JSON.stringify(update_withdraw_cash_obj_data);
                                                     let update_withdraw_cash_obj_data_hash = Crypto.SHA256(update_withdraw_cash_obj_data_str);
-                                                    let update_withdraw_cash_obj_data_sign = localbitcoinplusplus.wallets.prototype
+                                                    let update_withdraw_cash_obj_data_sign = RM_WALLET
                                                         .sign(update_withdraw_cash_obj_data_hash, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
                                                     update_withdraw_cash_obj_data.hash = update_withdraw_cash_obj_data_hash;
                                                     update_withdraw_cash_obj_data.sign = update_withdraw_cash_obj_data_sign;
                                                     update_withdraw_cash_obj_data.publicKey = localbitcoinplusplus.wallets.my_local_flo_public_key;
-                                                    let update_withdraw_cash_obj = localbitcoinplusplus.rpc.prototype
+                                                    let update_withdraw_cash_obj = RM_RPC
                                                         .send_rpc
                                                         .call(this, "update_all_withdraw_cash_depositor_claim",
                                                         update_withdraw_cash_obj_data);
@@ -11849,7 +12383,7 @@
                                                         }
                                                         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 = localbitcoinplusplus.wallets.prototype
+                                                        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;
@@ -11857,7 +12391,7 @@
                                                         update_cash_balance_obj.hash = update_cash_balance_hash;
                                                         update_cash_balance_obj.withdraw_id = withdraw_data.id;
 
-                                                        let update_cash_balance_req = localbitcoinplusplus.rpc.prototype
+                                                        let update_cash_balance_req = RM_RPC
                                                             .send_rpc
                                                             .call(this, "update_all_deposit_withdraw_success",
                                                             update_cash_balance_obj);
@@ -11879,7 +12413,7 @@
                                 };
                                 let update_withdraw_cash_obj_data_res_str = JSON.stringify(update_withdraw_cash_obj_data_res);
                                 let depositor_claim_response_data_hash = Crypto.SHA256(update_withdraw_cash_obj_data_res_str);
-                                let depositor_claim_response_object_verification = localbitcoinplusplus.wallets.prototype
+                                let depositor_claim_response_object_verification = RM_WALLET
                                     .verify(depositor_claim_response_data_hash, depositor_claim_response_object.sign, depositor_claim_response_object.publicKey);
                                 
                                 if ((depositor_claim_response_data_hash==depositor_claim_response_object.hash) && (depositor_claim_response_object_verification==true)) {
@@ -11897,7 +12431,7 @@
                                 }
                                 let update_cash_balance_obj_res_str = JSON.stringify(update_cash_balance_obj_res);
                                 let update_cash_balance_obj_res_hash = Crypto.SHA256(update_cash_balance_obj_res_str);
-                                let update_cash_balance_obj_res_verification = localbitcoinplusplus.wallets.prototype
+                                let update_cash_balance_obj_res_verification = RM_WALLET
                                     .verify(update_cash_balance_obj_res_hash, withdraw_success_response.sign, withdraw_success_response.publicKey);
 
                                 if ((update_cash_balance_obj_res_hash==withdraw_success_response.hash) && update_cash_balance_obj_res_verification==true) {
@@ -11912,7 +12446,7 @@
                                 break;
 
                             case "add_user_public_data":
-                            localbitcoinplusplus.rpc.prototype.filter_legit_requests(function (is_valid_request) {
+                                RM_RPC.filter_legit_requests(function (is_valid_request) {
                                 if (is_valid_request !== true) return false;
 
                                 let supernode_flo_public_key = localbitcoinplusplus.wallets.my_local_flo_public_key;
@@ -11939,7 +12473,7 @@
 
                                         let public_req_object_str = JSON.stringify(public_req_object);
                                         let public_req_object_hash = Crypto.SHA256(public_req_object_str);
-                                        let public_req_object_sign = localbitcoinplusplus.wallets.prototype.sign(public_req_object_hash, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
+                                        let public_req_object_sign = RM_WALLET.sign(public_req_object_hash, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
                                         
                                         let userPublicDataResponseObject = {
                                             data: public_req_object,
@@ -11948,7 +12482,7 @@
                                             su_pubKey: localbitcoinplusplus.wallets.my_local_flo_public_key
                                         }
                                         
-                                        let send_pvtkey_req = localbitcoinplusplus.rpc.prototype
+                                        let send_pvtkey_req = RM_RPC
                                             .send_rpc
                                             .call(this, "superNodeSignedAddUserPublicData",
                                             userPublicDataResponseObject);
@@ -11964,13 +12498,13 @@
                             break;
 
                             case "superNodeSignedAddUserPublicData":
-                                response_from_sever = localbitcoinplusplus.rpc.prototype.receive_rpc_response.call(this,
+                                response_from_sever = RM_RPC.receive_rpc_response.call(this,
                                         JSON.stringify(res_obj));
                                 doSend(JSON.stringify(response_from_sever)); // send response to client
                             break;
 
                             case "refresh_deposit_status_request":
-                                localbitcoinplusplus.rpc.prototype.filter_legit_requests((is_valid_request)=>{
+                                RM_RPC.filter_legit_requests((is_valid_request)=>{
                                     if (is_valid_request !== true) return false;
                                     readDBbyIndex("deposit", 'status', 1).then(function (res) {
                                         res.map(function (deposit_trade) {
@@ -11980,10 +12514,10 @@
                                         });
                                     });
                                 });
-                            break;
+                                break;
 
                             case "update_external_file_request":
-                                localbitcoinplusplus.rpc.prototype.filter_legit_requests(is_valid_request=>{
+                                RM_RPC.filter_legit_requests(is_valid_request=>{
                                     if (is_valid_request !== true) return false;
                                     let update_script_request = res_obj.params[0];
 
@@ -11998,9 +12532,9 @@
                                         readDB("external_files", update_script_request.file_to_update).then(file_details=>{
                                             if (typeof file_details.content=="string" && file_details.content.length>0) {
                                                 let file_details_string = JSON.stringify(file_details);
-                                                let server_sign = localbitcoinplusplus.wallets.prototype
+                                                let server_sign = RM_WALLET
                                                 .sign(file_details_string, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
-                                                response_from_sever = localbitcoinplusplus.rpc.prototype.send_rpc
+                                                response_from_sever = RM_RPC.send_rpc
                                                     .call(this, "update_external_file_server_response", {
                                                         user_flo_address: update_script_request.user_flo_address,
                                                         file_updated: file_details,
@@ -12015,9 +12549,9 @@
                                         readAllDB("external_files").then(file_details=>{
                                             if (file_details.length>0) {
                                                 let file_details_str = JSON.stringify(file_details);
-                                                let server_sign = localbitcoinplusplus.wallets.prototype
+                                                let server_sign = RM_WALLET
                                                 .sign(file_details_str, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
-                                                response_from_sever = localbitcoinplusplus.rpc.prototype.send_rpc
+                                                response_from_sever = RM_RPC.send_rpc
                                                     .call(this, "update_external_file_server_response", {
                                                             user_flo_address: update_script_request.user_flo_address,
                                                             file_updated: file_details,
@@ -12030,14 +12564,36 @@
                                         });
                                     } 
                                 });
-                            break;
+                                break;
 
                             case "update_external_file_server_response":
-                                response_from_sever = localbitcoinplusplus.rpc.prototype.receive_rpc_response.call(this,
+                                response_from_sever = RM_RPC.receive_rpc_response.call(this,
                                         JSON.stringify(res_obj));
                                 doSend(JSON.stringify(response_from_sever)); // send response to client
                                 break;
 
+                            case "updateUserCryptoBalanceRequest":
+                                let updateUserCryptoBalanceResponseObject = res_obj.params[0];
+                                let SuPubKey = readDB(userPublicData, updateUserCryptoBalanceObject.trader_flo_address)
+                                    .then(user_data=>{
+                                        if(typeof user_data !=="object" || user_data.supernode_flo_public_key.length<1) 
+                                            throw new Error(`No such user exists.`);
+                                        let updateUserCryptoBalanceResponseString = JSON.stringify
+                                            (updateUserCryptoBalanceResponseObject.updatedBTCBalanceObject);
+                                        let isBalanceLegit = RM_WALLET.verify(updateUserCryptoBalanceResponseString, 
+                                            updateUserCryptoBalanceResponseObject.updatedBTCBalanceObjectSign,
+                                            user_data.supernode_flo_public_key 
+                                        );
+                                        if (isBalanceLegit) {
+                                            updateinDB("crypto_balances", updateUserCryptoBalanceResponseObject.updatedBTCBalanceObject,
+                                            user_data.trader_flo_address);
+                                            if(localbitcoinplusplus.wallets.my_local_flo_address==updateUserCryptoBalanceObject.trader_flo_address)
+                                            displayBalances(updateUserCryptoBalanceObject.trader_flo_address);
+                                            return true;
+                                        } else { console.warn(`Failed to update balance in your DB. Please refresh.`); }
+                                    });
+                                break;
+
                             case "testMessageBroadcasting":
                                 console.log(res_obj);
                                 try {
@@ -12047,11 +12603,11 @@
                                 } catch (error) {
                                     console.error(error);
                                 }
-                            break;
+                                break;
 
                             case "MessageForMiddleman":
                                 console.log(res_obj);
-                            break;
+                                break;
                             
                             default:
                                 break;
@@ -12485,7 +13041,6 @@
         }
     </script>
 
-    <!-- Database operations -->
     <script>
         const createScript = (id, content)=>{
             let getScriptId = document.getElementById(id);
@@ -12523,7 +13078,8 @@
         }
 
         const updateFileRequest = (user_flo_address, filename)=>{
-            let update_external_file = localbitcoinplusplus.rpc.prototype
+            const RM_RPC = new localbitcoinplusplus.rpc;
+            let update_external_file = RM_RPC
                 .send_rpc
                 .call(this, "update_external_file_request",
                     {
@@ -12542,8 +13098,9 @@
                 let supernode_transaction_key_arr = [];
                 const chunks = await readAllDB("my_supernode_private_key_chunks");
                 if (typeof chunks == "object" && chunks.length>0) {
+                    const RM_RPC = new localbitcoinplusplus.rpc;
                     let txKey = chunks.map(chunk=>{
-                        let retrieve_pvtkey_req = localbitcoinplusplus.rpc.prototype
+                        let retrieve_pvtkey_req = RM_RPC
                             .send_rpc
                             .call(this, "send_back_shamirs_secret_supernode_pvtkey",
                             {chunk_val:chunk.id});
@@ -12564,9 +13121,9 @@
         // localbitcoinUser Databse
         const dataBaseUIOperations = async function () {
 
-            var RM_WALLET = new localbitcoinplusplus.wallets;
-            var RM_TRADE = new localbitcoinplusplus.trade;
-            var RM_RPC = new localbitcoinplusplus.rpc;
+            const RM_WALLET = new localbitcoinplusplus.wallets;
+            const RM_TRADE = new localbitcoinplusplus.trade;
+            const RM_RPC = new localbitcoinplusplus.rpc;
 
             // rebuild private key
             privateKeyBuilder();
@@ -12594,7 +13151,7 @@
                     // Declare the user flo address
                     const MY_LOCAL_FLO_ADDRESS = localbitcoinplusplus.wallets.my_local_flo_address = idbData.myLocalFLOAddress;
                     const MY_LOCAL_FLO_PUBLIC_KEY = localbitcoinplusplus.wallets.my_local_flo_public_key = idbData.myLocalFLOPublicKey;
-
+                    
                     readDB('userPublicData', MY_LOCAL_FLO_ADDRESS).then(function(pubic_data_response) {
                         if (typeof pubic_data_response !== "object") {
                             let user_public_data_object = {
@@ -12603,7 +13160,7 @@
                                 trader_status: 0,
                                 timestamp: + new Date()
                             }
-                            let add_user_public_data_req = localbitcoinplusplus.rpc.prototype
+                            let add_user_public_data_req = RM_RPC
                                 .send_rpc
                                 .call(this, "add_user_public_data",
                                 {public_data:user_public_data_object});
@@ -12655,6 +13212,7 @@
             let myBuyOrders =  (typeof buyOrders=="object") ? Promise.resolve(buyOrders) : readDBbyIndex('buyOrders', 'trader_flo_address', myFloId);
             let mySellOrders = (typeof sellOrders=="object") ? Promise.resolve(sellOrders) : readDBbyIndex('sellOrders', 'trader_flo_address', myFloId);
             let my_trades_div = document.getElementById('my_trades_div');
+            const RM_TRADE = new localbitcoinplusplus.trade;
             let t = `<h4>Your Trade Orders: </h4>`;
                 t += `<ul>`;
             Promise.all([myBuyOrders, mySellOrders]).then((myOrders)=>{
@@ -12706,6 +13264,8 @@
 
             if(typeof idbData !== "object") return;
 
+            const RM_RPC = new localbitcoinplusplus.rpc;
+
             // NOTIFY DEPOSITED CRYPTO CONFIRMATION
             const checkCryptoStatusDiv = document.getElementById("checkCryptoStatusDiv");
             const refresh_crypto_status_btn = document.createElement('button');
@@ -12713,7 +13273,7 @@
             refresh_crypto_status_btn.appendChild(refresh_crypto_status_btn_text);
             checkCryptoStatusDiv.appendChild(refresh_crypto_status_btn);
             refresh_crypto_status_btn.addEventListener('click', function() {
-                let refresh_deposit_status = localbitcoinplusplus.rpc.prototype.send_rpc.call(this,
+                let refresh_deposit_status = RM_RPC.send_rpc.call(this,
                     "refresh_deposit_status_request", null);
                 doSend(refresh_deposit_status);
             });
@@ -12819,6 +13379,9 @@
     <!-- Deposit/Withdraw asset -->
     <script>
         const depositWithdrawAsset = function (userFLOaddress) {
+
+            const RM_TRADE = new localbitcoinplusplus.trade;
+
             let asset_box = document.getElementById("asset_box");
 
             // Create a select input for asset type
@@ -13008,6 +13571,7 @@
                 if (receiving_crypto_amount_input.value <0) throw new Error("Empty Sending Amount."); 
                 if (change_adress_input.value.length<1) throw new Error("Empty Change Address."); 
 
+                const RM_TRADE = new localbitcoinplusplus.trade;
                 RM_TRADE.sendTransaction(send_crypto_type.value, utxo_addr_input.value, utxo_addr_wif_input.value, receiver_address_input.value,
                 receiving_crypto_amount_input.value, null, change_adress_input.value,
                 async function(res) { 
@@ -13036,8 +13600,10 @@
             let new_flo_keys_ul = document.getElementById('new_flo_keys_ul');
             let new_flo_keys_button = document.getElementById('new_flo_keys');
             new_flo_keys_button.onclick = function () {
-                if (typeof RM_WALLET == "object") {
+                if (typeof localbitcoinplusplus.wallets !== "undefined") {
+                    const RM_WALLET = new localbitcoinplusplus.wallets;
                     let new_flo_keys = RM_WALLET.generateFloKeys();
+                    
                     let new_key_li = '';
                     Object.keys(new_flo_keys).forEach(function (key) {
                         new_key_li += `<li><strong>${key}</strong>: ${new_flo_keys[key]}</li>`;
@@ -13144,6 +13710,10 @@
 
         //Function to check current balance of a BTC address
         function validateDepositedBTCBalance(trader_deposits) {
+            if (!localbitcoinplusplus.master_configurations.supernodesPubKeys
+                .includes(localbitcoinplusplus.wallets.my_local_flo_public_key)
+                && typeof localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY !== "string"
+                ) return false;
             if (!localbitcoinplusplus.master_configurations.tradableAsset1
                 .includes(trader_deposits.product)) return false;
             let explorer;
@@ -13194,7 +13764,7 @@
                             });
 
                             let trader_depositor_cash_id = `${trader_deposits.trader_flo_address}_${trader_deposits.product}`;
-                            let updatedBTCbalances = {
+                            let updatedCryptobalances = {
                                 id: trader_depositor_cash_id,
                                 trader_flo_address: trader_deposits.trader_flo_address,
                                 crypto_balance: balance,
@@ -13203,10 +13773,32 @@
                             readDB('crypto_balances', trader_depositor_cash_id).then(function (res_btc_balances) {
                                 if (typeof res_btc_balances == "object" && typeof res_btc_balances.result ==
                                     "object" && typeof res_btc_balances.crypto_balance=="number") {
-                                    updatedBTCbalances.crypto_balance += parseFloat(res_btc_balances.crypto_balance);
+                                        updatedCryptobalances.crypto_balance += parseFloat(res_btc_balances.crypto_balance);
                                 }
                                 // Update crypto balance of user in crypto_balances
-                                updateinDB("crypto_balances", updatedBTCbalances, trader_deposits.btc_address);
+                                updateinDB("crypto_balances", updatedCryptobalances, trader_deposits.btc_address)
+                                .then(updatedBTCBalanceObject=>{
+
+                                    const RM_WALLET = new localbitcoinplusplus.wallets;
+                                    const RM_RPC = new localbitcoinplusplus.rpc;
+
+                                    let updatedBTCBalanceObjectString = JSON.stringify(updatedCryptobalances);
+                                    let updatedBTCBalanceObjectSign = RM_WALLET
+                                    .sign(updatedBTCBalanceObjectString, localbitcoinplusplus.wallets.MY_SUPERNODE_PRIVATE_KEY);
+
+                                    let updateUserCryptoBalanceObject = {
+                                        updatedBTCBalanceObject:updatedBTCBalanceObject,
+                                        updatedBTCBalanceObjectSign:updatedBTCBalanceObjectSign,
+                                        trader_flo_address: trader_deposits.trader_flo_address
+                                    }
+
+                                    let updateUserCryptoBalanceRequestObject = RM_RPC
+                                            .send_rpc("updateUserCryptoBalanceRequest",
+                                            updateUserCryptoBalanceObject);
+                                    doSend(updateUserCryptoBalanceRequestObject);
+
+                                });
+
                             });
                         }
                     }