diff --git a/index.html b/index.html
index 12e9c00..8964170 100644
--- a/index.html
+++ b/index.html
@@ -7560,17 +7560,18 @@
             }
         }
     </script>
-    <script id="floBlockchainAPI" version="2.0.1c">
+    <script id="floBlockchainAPI" version="2.1.1a">
         /* FLO Blockchain Operator to send/receive data from blockchain using API calls*/
         const floBlockchainAPI = {
     
             util: {
                 serverList: floGlobals.apiURL[floGlobals.blockchain].slice(0),
-                curPos: floCrypto.randInt(0, floGlobals.apiURL[floGlobals.blockchain].length),
-                fetch_retry: function(apicall) {
+                curPos: floCrypto.randInt(0, floGlobals.apiURL[floGlobals.blockchain].length - 1),
+                fetch_retry: function(apicall, rm_flosight) {
                     return new Promise((resolve, reject) => {
-                        this.serverList.splice(this.curPos, 1);
-                        this.curPos = floCrypto.randInt(0, this.serverList.length - 1)
+                        let i = this.serverList.indexOf(rm_flosight)
+                        if (i != -1) this.serverList.splice(i, 1);
+                        this.curPos = floCrypto.randInt(0, this.serverList.length - 1);
                         this.fetch_api(apicall)
                             .then(result => resolve(result))
                             .catch(error => reject(error));
@@ -7579,30 +7580,35 @@
                 fetch_api: function(apicall) {
                     return new Promise((resolve, reject) => {
                         if (this.serverList.length === 0)
-                            reject("No floSight server working")
+                            reject("No floSight server working");
                         else {
-                            fetch(this.serverList[this.curPos] + apicall).then(response => {
+                            let flosight = this.serverList[this.curPos];
+                            fetch(flosight + apicall).then(response => {
                                 if (response.ok)
                                     response.json().then(data => resolve(data));
                                 else {
-                                    this.fetch_retry(apicall)
+                                    this.fetch_retry(apicall, flosight)
                                         .then(result => resolve(result))
                                         .catch(error => reject(error));
                                 }
                             }).catch(error => {
-                                this.fetch_retry(apicall)
+                                this.fetch_retry(apicall, flosight)
                                     .then(result => resolve(result))
                                     .catch(error => reject(error));
                             })
                         }
                     })
+                },
+    
+                current: function() {
+                    return this.serverList[this.curPos];
                 }
             },
     
             //Promised function to get data from API
             promisedAPI: function(apicall) {
                 return new Promise((resolve, reject) => {
-                    console.log(apicall)
+                    //console.log(apicall);
                     this.util.fetch_api(apicall)
                         .then(result => resolve(result))
                         .catch(error => reject(error));
@@ -7619,57 +7625,75 @@
             },
     
             //Write Data into blockchain
-            writeData: function(senderAddr, data, privKey, receiverAddr = floGlobals.adminID) {
+            writeData: function(senderAddr, data, privKey, receiverAddr = floGlobals.adminID, strict_utxo = true) {
                 return new Promise((resolve, reject) => {
                     if (typeof data != "string")
                         data = JSON.stringify(data);
-                    this.sendTx(senderAddr, receiverAddr, floGlobals.sendAmt, privKey, data)
+                    this.sendTx(senderAddr, receiverAddr, floGlobals.sendAmt, privKey, data, strict_utxo)
                         .then(txid => resolve(txid))
-                        .catch(error => reject(error))
+                        .catch(error => reject(error));
                 });
             },
     
             //Send Tx to blockchain 
-            sendTx: function(senderAddr, receiverAddr, sendAmt, privKey, floData = '') {
+            sendTx: function(senderAddr, receiverAddr, sendAmt, privKey, floData = '', strict_utxo = true) {
                 return new Promise((resolve, reject) => {
                     if (!floCrypto.validateASCII(floData))
                         return reject("Invalid FLO_Data: only printable ASCII characters are allowed");
-                    if (!floCrypto.validateAddr(senderAddr))
-                        reject(`Invalid address : ${senderAddr}`);
+                    else if (!floCrypto.validateAddr(senderAddr))
+                        return reject(`Invalid address : ${senderAddr}`);
                     else if (!floCrypto.validateAddr(receiverAddr))
-                        reject(`Invalid address : ${receiverAddr}`);
-                    if (privKey.length < 1 || !floCrypto.verifyPrivKey(privKey, senderAddr))
-                        reject("Invalid Private key!");
+                        return reject(`Invalid address : ${receiverAddr}`);
+                    else if (privKey.length < 1 || !floCrypto.verifyPrivKey(privKey, senderAddr))
+                        return reject("Invalid Private key!");
                     else if (typeof sendAmt !== 'number' || sendAmt <= 0)
-                        reject(`Invalid sendAmt : ${sendAmt}`);
-                    else {
-                        var trx = bitjs.transaction();
-                        var utxoAmt = 0.0;
-                        var fee = floGlobals.fee;
-                        this.promisedAPI(`api/addr/${senderAddr}/utxo`).then(utxos => {
-                            for (var i = utxos.length - 1;
-                                (i >= 0) && (utxoAmt < sendAmt + fee); i--) {
-                                if (utxos[i].confirmations) {
-                                    trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i]
-                                        .scriptPubKey)
-                                    utxoAmt += utxos[i].amount;
-                                } else break;
-                            }
-                            if (utxoAmt < sendAmt + fee)
-                                reject("Insufficient balance!");
-                            else {
-                                trx.addoutput(receiverAddr, sendAmt);
-                                var change = utxoAmt - sendAmt - fee;
-                                if (change > 0)
-                                    trx.addoutput(senderAddr, change);
-                                trx.addflodata(floData.replace(/\n/g, ' '));
-                                var signedTxHash = trx.sign(privKey, 1);
-                                this.broadcastTx(signedTxHash)
-                                    .then(txid => resolve(txid))
-                                    .catch(error => reject(error))
-                            }
+                        return reject(`Invalid sendAmt : ${sendAmt}`);
+    
+                    //get unconfirmed tx list
+                    this.promisedAPI(`api/addr/${senderAddr}`).then(result => {
+                        this.readTxs(senderAddr, 0, result.unconfirmedTxApperances).then(result => {
+                            let unconfirmedSpent = {};
+                            for (let tx of result.items)
+                                if (tx.confirmations == 0)
+                                    for (let vin of tx.vin)
+                                        if (vin.addr === senderAddr) {
+                                            if (Array.isArray(unconfirmedSpent[vin.txid]))
+                                                unconfirmedSpent[vin.txid].push(vin.vout);
+                                            else
+                                                unconfirmedSpent[vin.txid] = [vin.vout];
+                                        }
+                            //get utxos list
+                            this.promisedAPI(`api/addr/${senderAddr}/utxo`).then(utxos => {
+                                //form/construct the transaction data
+                                var trx = bitjs.transaction();
+                                var utxoAmt = 0.0;
+                                var fee = floGlobals.fee;
+                                for (var i = utxos.length - 1;
+                                    (i >= 0) && (utxoAmt < sendAmt + fee); i--) {
+                                    //use only utxos with confirmations (strict_utxo mode)
+                                    if (utxos[i].confirmations || !strict_utxo) {
+                                        if (utxos[i].txid in unconfirmedSpent && unconfirmedSpent[utxos[i].txid].includes(utxos[i].vout))
+                                            continue; //A transaction has already used this utxo, but is unconfirmed.
+                                        trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i].scriptPubKey);
+                                        utxoAmt += utxos[i].amount;
+                                    };
+                                }
+                                if (utxoAmt < sendAmt + fee)
+                                    reject("Insufficient FLO balance!");
+                                else {
+                                    trx.addoutput(receiverAddr, sendAmt);
+                                    var change = utxoAmt - sendAmt - fee;
+                                    if (change > 0)
+                                        trx.addoutput(senderAddr, change);
+                                    trx.addflodata(floData.replace(/\n/g, ' '));
+                                    var signedTxHash = trx.sign(privKey, 1);
+                                    this.broadcastTx(signedTxHash)
+                                        .then(txid => resolve(txid))
+                                        .catch(error => reject(error))
+                                }
+                            }).catch(error => reject(error))
                         }).catch(error => reject(error))
-                    }
+                    }).catch(error => reject(error))
                 });
             },
     
@@ -7679,21 +7703,18 @@
                     if (!floCrypto.validateAddr(floID))
                         return reject(`Invalid floID`);
                     if (!floCrypto.verifyPrivKey(privKey, floID))
-                        return reject("Invalid Private Key")
+                        return reject("Invalid Private Key");
                     if (!floCrypto.validateASCII(floData))
                         return reject("Invalid FLO_Data: only printable ASCII characters are allowed");
-    
                     var trx = bitjs.transaction();
                     var utxoAmt = 0.0;
                     var fee = floGlobals.fee;
                     this.promisedAPI(`api/addr/${floID}/utxo`).then(utxos => {
-                        for (var i = utxos.length - 1; i >= 0; i--) {
+                        for (var i = utxos.length - 1; i >= 0; i--)
                             if (utxos[i].confirmations) {
-                                trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i]
-                                    .scriptPubKey)
+                                trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i].scriptPubKey);
                                 utxoAmt += utxos[i].amount;
                             }
-                        }
                         trx.addoutput(floID, utxoAmt - fee);
                         trx.addflodata(floData.replace(/\n/g, ' '));
                         var signedTxHash = trx.sign(privKey, 1);
@@ -7714,15 +7735,15 @@
             writeDataMultiple: function(senderPrivKeys, data, receivers = [floGlobals.adminID], preserveRatio = true) {
                 return new Promise((resolve, reject) => {
                     if (!Array.isArray(senderPrivKeys))
-                        return reject("Invalid senderPrivKeys: SenderPrivKeys must be Array")
+                        return reject("Invalid senderPrivKeys: SenderPrivKeys must be Array");
                     if (!preserveRatio) {
                         let tmp = {};
                         let amount = (floGlobals.sendAmt * receivers.length) / senderPrivKeys.length;
                         senderPrivKeys.forEach(key => tmp[key] = amount);
-                        senderPrivKeys = tmp
+                        senderPrivKeys = tmp;
                     }
                     if (!Array.isArray(receivers))
-                        return reject("Invalid receivers: Receivers must be Array")
+                        return reject("Invalid receivers: Receivers must be Array");
                     else {
                         let tmp = {};
                         let amount = floGlobals.sendAmt;
@@ -7785,9 +7806,8 @@
                                     if (!key)
                                         invalids.InvalidSenderPrivKeys.push(key);
                                     else {
-                                        if (typeof senderPrivKeys[key] !== 'number' || senderPrivKeys[
-                                                key] <= 0)
-                                            invalids.InvalidSenderAmountFor.push(key)
+                                        if (typeof senderPrivKeys[key] !== 'number' || senderPrivKeys[key] <= 0)
+                                            invalids.InvalidSenderAmountFor.push(key);
                                         else
                                             inputVal += senderPrivKeys[key];
                                         let floID = floCrypto.getFloID(key);
@@ -7805,9 +7825,9 @@
                         //Validate the receiver IDs and receive amount
                         for (let floID in receivers) {
                             if (!floCrypto.validateAddr(floID))
-                                invalids.InvalidReceiverIDs.push(floID)
+                                invalids.InvalidReceiverIDs.push(floID);
                             if (typeof receivers[floID] !== 'number' || receivers[floID] <= 0)
-                                invalids.InvalidReceiveAmountFor.push(floID)
+                                invalids.InvalidReceiveAmountFor.push(floID);
                             else
                                 outputVal += receivers[floID];
                         }
@@ -7819,15 +7839,14 @@
                             return reject(invalids);
                         //Reject if given inputVal and outputVal are not equal
                         if (!preserveRatio && inputVal != outputVal)
-                            return reject(
-                                `Input Amount (${inputVal}) not equal to Output Amount (${outputVal})`)
+                            return reject(`Input Amount (${inputVal}) not equal to Output Amount (${outputVal})`);
                     } catch (error) {
                         return reject(error)
                     }
                     //Get balance of senders
-                    let promises = []
+                    let promises = [];
                     for (let floID in senders)
-                        promises.push(this.getBalance(floID))
+                        promises.push(this.getBalance(floID));
                     Promise.all(promises).then(results => {
                         let totalBalance = 0,
                             totalFee = floGlobals.fee,
@@ -7839,10 +7858,9 @@
                         let insufficient = [];
                         for (let floID in senders) {
                             balance[floID] = parseFloat(results.shift());
-                            if (isNaN(balance[floID]) || (preserveRatio && balance[floID] <=
-                                    totalFee) || (!preserveRatio && balance[floID] < senders[floID]
-                                    .coins + dividedFee))
-                                insufficient.push(floID)
+                            if (isNaN(balance[floID]) || (preserveRatio && balance[floID] <= totalFee) ||
+                                (!preserveRatio && balance[floID] < senders[floID].coins + dividedFee))
+                                insufficient.push(floID);
                             totalBalance += balance[floID];
                         }
                         if (insufficient.length)
@@ -7854,11 +7872,11 @@
                         for (floID in receivers)
                             totalSendAmt += receivers[floID];
                         if (totalBalance < totalSendAmt)
-                            return reject("Insufficient total Balance")
+                            return reject("Insufficient total Balance");
                         //Get the UTXOs of the senders
-                        let promises = []
+                        let promises = [];
                         for (floID in senders)
-                            promises.push(this.promisedAPI(`api/addr/${floID}/utxo`))
+                            promises.push(this.promisedAPI(`api/addr/${floID}/utxo`));
                         Promise.all(promises).then(results => {
                             let wifSeq = [];
                             var trx = bitjs.transaction();
@@ -7875,8 +7893,7 @@
                                 for (let i = utxos.length - 1;
                                     (i >= 0) && (utxoAmt < sendAmt); i--) {
                                     if (utxos[i].confirmations) {
-                                        trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i]
-                                            .scriptPubKey)
+                                        trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i].scriptPubKey);
                                         wifSeq.push(wif);
                                         utxoAmt += utxos[i].amount;
                                     }
@@ -7906,7 +7923,7 @@
                 return new Promise((resolve, reject) => {
                     var request = new XMLHttpRequest();
                     var url = this.util.serverList[this.util.curPos] + 'api/tx/send';
-                    console.log(url)
+                    console.log(url);
                     if (signedTxHash.length < 1)
                         reject("Empty Signature");
                     else {
@@ -7962,28 +7979,26 @@
             receivedOnly: filters only received data
             pattern     : filters data that with JSON pattern
             filter      : custom filter funtion for floData (eg . filter: d => {return d[0] == '$'})
-            txid        : (boolean) resolve txid or not
+            tx          : (boolean) resolve tx data or not (resolves an Array of Object with tx details)
             sender      : flo-id(s) of sender
             receiver    : flo-id(s) of receiver
             */
             readData: function(addr, options = {}) {
-                options.limit = options.limit || 0
-                options.ignoreOld = options.ignoreOld || 0
+                options.limit = options.limit || 0;
+                options.ignoreOld = options.ignoreOld || 0;
                 if (typeof options.sender === "string") options.sender = [options.sender];
                 if (typeof options.receiver === "string") options.receiver = [options.receiver];
                 return new Promise((resolve, reject) => {
                     this.promisedAPI(`api/addrs/${addr}/txs?from=0&to=1`).then(response => {
                         var newItems = response.totalItems - options.ignoreOld;
-                        this.promisedAPI(`api/addrs/${addr}/txs?from=0&to=${newItems*2}`).then(
-                            response => {
+                        this.promisedAPI(`api/addrs/${addr}/txs?from=0&to=${newItems*2}`).then(response => {
                                 if (options.limit <= 0)
                                     options.limit = response.items.length;
                                 var filteredData = [];
-                                for (i = 0; i < (response.totalItems - options.ignoreOld) &&
-                                    filteredData.length < options.limit; i++) {
+                                for (let i = 0; i < (response.totalItems - options.ignoreOld) && filteredData.length < options.limit; i++) {
                                     if (options.pattern) {
                                         try {
-                                            let jsonContent = JSON.parse(response.items[i].floData)
+                                            let jsonContent = JSON.parse(response.items[i].floData);
                                             if (!Object.keys(jsonContent).includes(options.pattern))
                                                 continue;
                                         } catch (error) {
@@ -8028,7 +8043,16 @@
                                     }
                                     if (options.filter && !options.filter(response.items[i].floData))
                                         continue;
-                                    filteredData.push(options.txid ? [response.items[i].txid, response.items[i].floData] : response.items[i].floData);
+    
+                                    if (options.tx) {
+                                        let d = {}
+                                        d.txid = response.items[i].txid;
+                                        d.time = response.items[i].time;
+                                        d.blockheight = response.items[i].blockheight;
+                                        d.data = response.items[i].floData;
+                                        filteredData.push(d);
+                                    } else
+                                        filteredData.push(response.items[i].floData);
                                 }
                                 resolve({
                                     totalTxs: response.totalItems,
@@ -8297,7 +8321,7 @@
             }
         }
     </script>
-    <script id="floCloudAPI" version="2.0.2e">
+    <script id="floCloudAPI" version="2.1.0a">
         /* FLO Cloud operations to send/request application data*/
         const floCloudAPI = {
     
@@ -8442,23 +8466,16 @@
                 },
     
                 inactive: new Set(),
-                connect(snID) {
+    
+                ws_connect(snID) {
                     return new Promise((resolve, reject) => {
                         if (!(snID in floGlobals.supernodes))
                             return reject(`${snID} is not a supernode`)
                         let inactive = this.inactive
                         if (inactive.has(snID))
                             return reject(`${snID} is not active`)
-                        var wsConn = new WebSocket("wss://" + floGlobals.supernodes[snID].uri + "/ws");
-                        wsConn.onmessage = (evt) => {
-                            if (evt.data == '$+')
-                                resolve(wsConn)
-                            else if (evt.data == '$-') {
-                                wsConn.close();
-                                inactive.add(snID)
-                                reject(`${snID} is not active`)
-                            }
-                        }
+                        var wsConn = new WebSocket("wss://" + floGlobals.supernodes[snID].uri + "/");
+                        wsConn.onopen = evt => resolve(wsConn);
                         wsConn.onerror = evt => {
                             inactive.add(snID)
                             reject(`${snID} is unavailable`)
@@ -8466,51 +8483,88 @@
                     })
                 },
     
-                connectActive(snID, reverse = false) {
+                ws_activeConnect(snID, reverse = false) {
                     return new Promise((resolve, reject) => {
                         if (this.inactive.size === this.kBucket.SNCO.length)
-                            return reject('Cloud offline')
+                            return reject('Cloud offline');
                         if (!(snID in floGlobals.supernodes))
                             snID = this.kBucket.closestNode(snID);
-                        this.connect(snID)
+                        this.ws_connect(snID)
                             .then(node => resolve(node))
                             .catch(error => {
                                 if (reverse)
                                     var nxtNode = this.kBucket.prevNode(snID);
                                 else
                                     var nxtNode = this.kBucket.nextNode(snID);
-                                this.connectActive(nxtNode, reverse)
+                                this.ws_activeConnect(nxtNode, reverse)
                                     .then(node => resolve(node))
                                     .catch(error => reject(error))
                             })
                     })
                 },
     
-                singleRequest: function(floID, data) {
+                fetch_API: function(snID, data) {
                     return new Promise((resolve, reject) => {
-                        this.connectActive(floID).then(node => {
-                            let randID = floCrypto.randString(5);
-                            node.send(`${floID}|${randID}:${JSON.stringify(data)}`);
-                            node.onmessage = (evt) => {
-                                if (evt.data.startsWith(randID, 1)) {
-                                    try {
-                                        let data = JSON.parse(evt.data.substring(42))
-                                        resolve(data)
-                                    } catch (error) {
-                                        reject(evt.data.substring(42))
-                                    } finally {
-                                        node.close()
-                                    }
-                                }
-                            }
-                        }).catch(error => reject(error));
-                    });
+                        if (this.inactive.has(snID))
+                            return reject(`${snID} is not active`);
+                        let fetcher, sn_url = "https://" + floGlobals.supernodes[snID].uri;
+                        if (typeof data === "string")
+                            fetcher = fetch(sn_url + "?" + data);
+                        else if (typeof data === "object" && data.method === "POST")
+                            fetcher = fetch(sn_url, data);
+                        fetcher.then(response => {
+                            if (response.ok)
+                                resolve(response);
+                            else
+                                reject(response);
+                        }).catch(error => reject(error))
+                    })
                 },
     
-                liveRequest: function(floID, datareq, callback) {
-                    let request = {
-                        ...datareq.request
-                    };
+                fetch_ActiveAPI: function(snID, data, reverse = false) {
+                    return new Promise((resolve, reject) => {
+                        if (this.inactive.size === this.kBucket.SNCO.length)
+                            return reject('Cloud offline');
+                        if (!(snID in floGlobals.supernodes))
+                            snID = this.kBucket.closestNode(snID);
+                        this.fetch_API(snID, data)
+                            .then(result => resolve(result))
+                            .catch(error => {
+                                this.inactive.add(snID)
+                                if (reverse)
+                                    var nxtNode = this.kBucket.prevNode(snID);
+                                else
+                                    var nxtNode = this.kBucket.nextNode(snID);
+                                this.fetch_ActiveAPI(nxtNode, data, reverse)
+                                    .then(result => resolve(result))
+                                    .catch(error => reject(error));
+                            })
+                    })
+                },
+    
+                singleRequest: function(floID, data_obj, method = "POST") {
+                    return new Promise((resolve, reject) => {
+                        let data;
+                        if (method === "POST")
+                            data = {
+                                method: "POST",
+                                body: JSON.stringify(data_obj)
+                            };
+                        else
+                            data = new URLSearchParams(JSON.parse(JSON.stringify(data_obj))).toString();
+                        this.fetch_ActiveAPI(floID, data).then(response => {
+                            response.json()
+                                .then(result => resolve(this.objectifier(result)))
+                                .catch(error => {
+                                    response.text()
+                                        .then(result => reject(result)) //Error Message from Node
+                                        .catch(error => reject(error))
+                                })
+                        }).catch(error => reject(error))
+                    })
+                },
+    
+                liveRequest: function(floID, request, callback) {
                     const checkFilter = (v, d, r) =>
                         (!r.atVectorClock || r.atVectorClock == v) &&
                         (r.atVectorClock || !r.lowerVectorClock || r.lowerVectorClock <= v) &&
@@ -8521,25 +8575,20 @@
                         (!r.type || r.type == d.type) &&
                         (!r.senderIDs || r.senderIDs.includes(d.senderID));
                     return new Promise((resolve, reject) => {
-                        this.connectActive(floID).then(node => {
+                        this.ws_activeConnect(floID).then(node => {
                             let randID = floCrypto.randString(5);
-                            node.send(`${floID}|${randID}:${JSON.stringify(datareq)}`);
+                            node.send(JSON.stringify(request));
                             node.onmessage = (evt) => {
-                                if (evt.data.startsWith(randID, 1))
-                                    var i = 42
-                                else if (evt.data.startsWith(floID, 1))
-                                    var i = 36
-                                else return;
                                 let d = e = null;
                                 try {
-                                    let data = JSON.parse(evt.data.substring(i))
-                                    let filter = {}
+                                    let data = this.objectifier(JSON.parse(evt.data)),
+                                        filter = {};
                                     for (let v in data)
                                         if (checkFilter(v, data[v], request))
-                                            filter[v] = data[v]
-                                    d = filter
+                                            filter[v] = data[v];
+                                    d = filter;
                                 } catch (error) {
-                                    e = evt.data.substring(i)
+                                    e = evt.data
                                 } finally {
                                     callback(d, e)
                                 }
@@ -8585,9 +8634,8 @@
                                         floGlobals.appObjects[dataSet[vc].type] = dataSet[vc].message.reset;
                                     break;
                                 case "UPDATE":
-                                    if (dataSet[vc].message.update)
-                                        floGlobals.appObjects[dataSet[vc].type] = mergeDiff(floGlobals
-                                            .appObjects[dataSet[vc].type], message.diff)
+                                    if (dataSet[vc].message.diff)
+                                        floGlobals.appObjects[dataSet[vc].type] = mergeDiff(floGlobals.appObjects[dataSet[vc].type], dataSet[vc].message.diff)
                             }
                             floGlobals.lastVC[dataSet[vc].type] = vc;
                             updatedObjects.add(dataSet[vc].type)
@@ -8614,6 +8662,15 @@
                     } catch (error) {
                         console.error(error)
                     }
+                },
+    
+                objectifier: function(data) {
+                    if (!Array.isArray(data))
+                        data = [data];
+                    return Object.fromEntries(data.map(d => {
+                        d.message = this.decodeMessage(d.message);
+                        return [d.vectorClock, d];
+                    }));
                 }
             },
     
@@ -8634,12 +8691,8 @@
                         .map(d => data[d]).join("|")
                     data.sign = floCrypto.signData(hashcontent, myPrivKey)
                     this.util.singleRequest(data.receiverID, data)
-                        .then(result => {
-                            data.message = message
-                            resolve({
-                                [result.vectorClock]: data
-                            })
-                        }).catch(error => reject(error))
+                        .then(result => resolve(result))
+                        .catch(error => reject(error))
                 })
             },
     
@@ -8657,30 +8710,24 @@
                         atVectorClock: options.atVectorClock || undefined,
                         mostRecent: options.mostRecent || undefined,
                     }
-                    var datareq = {
-                        time: Date.now(),
-                        request
-                    }
+    
                     if (options.callback instanceof Function) {
-                        let callback = (d, e) => {
-                            for (let v in d)
-                                d[v].message = this.util.decodeMessage(d[v].message)
-                            options.callback(d, e)
-                        }
-                        this.util.liveRequest(request.receiverID, datareq, callback)
+                        this.util.liveRequest(request.receiverID, request, options.callback)
                             .then(result => resolve(result))
                             .catch(error => reject(error))
                     } else {
-                        this.util.singleRequest(request.receiverID, datareq).then(data => {
-                            for (let v in data)
-                                data[v].message = this.util.decodeMessage(data[v].message)
-                            resolve(data)
-                        }).catch(error => reject(error))
+                        if (options.method === "POST")
+                            request = {
+                                time: Date.now(),
+                                request
+                            };
+                        this.util.singleRequest(request.receiverID, request, options.method || "GET")
+                            .then(data => resolve(data)).catch(error => reject(error))
                     }
                 })
             },
     
-            //delete data from supernode cloud (received only)
+            //(NEEDS UPDATE) delete data from supernode cloud (received only)
             deleteApplicationData: function(vectorClocks, options = {}) {
                 return new Promise((resolve, reject) => {
                     var delreq = {
@@ -8706,7 +8753,7 @@
                 })
             },
     
-            //edit comment of data in supernode cloud (mutable comments only)
+            //(NEEDS UPDATE) edit comment of data in supernode cloud (mutable comments only)
             editApplicationData: function(vectorClock, newComment, oldData, options = {}) {
                 return new Promise((resolve, reject) => {
                     let p0
@@ -8868,7 +8915,7 @@
                     if (!conn)
                         return reject('Request not found')
                     conn.onclose = evt => {
-                        delete this.util.liveRequest[requestID]
+                        delete this.util.liveRequest[requestID];
                         resolve('Request connection closed')
                     }
                     conn.close()