Changing to testnet

Added Taproot Changes
Added support for Multisig fee Editing
Exposed internal functions under btcOperator object

btcOperator.js

@@ -1,4 +1,4 @@
-(function (EXPORTS) { //btcOperator v1.1.3b
+(function (EXPORTS) { //btcOperator v1.1.3c
     /* BTC Crypto and API Operator */
     const btcOperator = EXPORTS;
 
@@ -92,6 +92,9 @@
         },
         bech32Address: {
             value: key => coinjs.bech32Address(btcOperator.pubkey(key)).address
+        },
+        bech32mAddress: {
+            value: key => segwit_addr.encode("bc", 1, key)
         }
     });
 
@@ -107,6 +110,8 @@
                 return btcOperator.segwitAddress(key) === addr;
             case "bech32":
                 return btcOperator.bech32Address(key) === addr;
+            case "bech32m":
+                return btcOperator.bech32mAddress(key) === addr; // Key is a byte array of 32 bytes    
             default:
                 return null;
         }
@@ -116,7 +121,7 @@
         if (!addr)
             return undefined;
         let type = coinjs.addressDecode(addr).type;
-        if (["standard", "multisig", "bech32", "multisigBech32"].includes(type))
+        if (["standard", "multisig", "bech32", "multisigBech32", "bech32m"].includes(type))
             return type;
         else
             return false;
@@ -281,6 +286,7 @@
         BECH32_OUTPUT_SIZE = 23,
         BECH32_MULTISIG_OUTPUT_SIZE = 34,
         SEGWIT_OUTPUT_SIZE = 23;
+    BECH32M_OUTPUT_SIZE = 35; // Check this later
 
     function _redeemScript(addr, key) {
         let decode = coinjs.addressDecode(addr);
@@ -291,10 +297,15 @@
                 return key ? coinjs.segwitAddress(btcOperator.pubkey(key)).redeemscript : null;
             case "bech32":
                 return decode.redeemscript;
+            case "'multisigBech32":
+                return decode.redeemscript; //Multisig-edit-fee-change1
+            case "bech32m":
+                return decode.outstring; //Maybe the redeemscript will come when input processing happens for bech32m   
             default:
                 return null;
         }
     }
+    btcOperator._redeemScript = _redeemScript;
 
     function _sizePerInput(addr, rs) {
         switch (coinjs.addressDecode(addr).type) {
@@ -328,6 +339,8 @@
                 return BASE_OUTPUT_SIZE + BECH32_MULTISIG_OUTPUT_SIZE;
             case "multisig":
                 return BASE_OUTPUT_SIZE + SEGWIT_OUTPUT_SIZE;
+            case "bech32m":
+                return BASE_OUTPUT_SIZE + BECH32M_OUTPUT_SIZE;
             default:
                 return null;
         }
@@ -379,6 +392,7 @@
         //return
         return parameters;
     }
+    btcOperator.validateTxParameters = validateTxParameters;
 
     function createTransaction(senders, redeemScripts, receivers, amounts, fee, change_address, fee_from_receiver) {
         return new Promise((resolve, reject) => {
@@ -417,6 +431,7 @@
             }).catch(error => reject(error))
         })
     }
+    btcOperator.createTransaction = createTransaction;
 
     function addInputs(tx, senders, redeemScripts, total_amount, fee, output_size, fee_from_receiver) {
         return new Promise((resolve, reject) => {
@@ -441,6 +456,7 @@
             }
         })
     }
+    btcOperator.addInputs = addInputs;
 
     function addUTXOs(tx, senders, redeemScripts, required_amount, fee_rate, rec_args = {}) {
         return new Promise((resolve, reject) => {
@@ -495,6 +511,7 @@
             }).catch(error => reject(error))
         })
     }
+    btcOperator.addUTXOs = addUTXOs;
 
     function addOutputs(tx, receivers, amounts, change_address) {
         let size = 0;
@@ -506,6 +523,7 @@
         size += _sizePerOutput(change_address);
         return size;
     }
+    btcOperator.addOutputs = addOutputs;
 
     /*
     function autoFeeCalc(tx) {
@@ -553,7 +571,19 @@
             } else resolve(deserializeTx(tx));
         })
     }
+    btcOperator.tx_fetch_for_editing = tx_fetch_for_editing;
 
+    const extractLastHexStrings = btcOperator.extractLastHexStrings = function (arr) {
+        const result = [];
+        for (let i = 0; i < arr.length; i++) {
+            const innerArray = arr[i];
+            if (innerArray.length > 0) {
+                const lastHexString = innerArray[innerArray.length - 1];
+                result.push(lastHexString);
+            }
+        }
+        return result;
+    }
 
     btcOperator.editFee = function (tx_hex, new_fee, private_keys, change_only = true) {
         return new Promise((resolve, reject) => {
@@ -644,10 +674,119 @@
         })
     }
 
+    btcOperator.editFee_corewallet = function(tx_hex, new_fee, private_keys, change_only = true) {
+    return new Promise((resolve, reject) => {
+        if (!Array.isArray(private_keys))
+            private_keys = [private_keys];
+        tx_fetch_for_editing(tx_hex).then(tx => {
+            parseTransaction(tx).then(tx_parsed => {
+                if (tx_parsed.fee >= new_fee)
+                    return reject("Fees can only be increased");
+
+                //editable addresses in output values (for fee increase)
+                var edit_output_address = new Set();
+                if (change_only === true) //allow only change values (ie, sender address) to be edited to inc fee
+                    tx_parsed.inputs.forEach(inp => edit_output_address.add(inp.address));
+                else if (change_only === false) //allow all output values to be edited
+                    tx_parsed.outputs.forEach(out => edit_output_address.add(out.address));
+                else if (typeof change_only == 'string') // allow only given receiver id output to be edited
+                    edit_output_address.add(change_only);
+                else if (Array.isArray(change_only)) //allow only given set of receiver id outputs to be edited
+                    change_only.forEach(id => edit_output_address.add(id));
+
+                //edit output values to increase fee
+                let inc_fee = util.BTC_to_Sat(new_fee - tx_parsed.fee);
+                if (inc_fee < MIN_FEE_UPDATE)
+                    return reject(`Insufficient additional fee. Minimum increment: ${MIN_FEE_UPDATE}`);
+                for (let i = tx.outs.length - 1; i >= 0 && inc_fee > 0; i--) //reduce in reverse order
+                    if (edit_output_address.has(tx_parsed.outputs[i].address)) {
+                        let current_value = tx.outs[i].value;
+                        if (current_value instanceof BigInteger) //convert BigInteger class to inv value
+                            current_value = current_value.intValue();
+                        //edit the value as required
+                        if (current_value > inc_fee) {
+                            tx.outs[i].value = current_value - inc_fee;
+                            inc_fee = 0;
+                        } else {
+                            inc_fee -= current_value;
+                            tx.outs[i].value = 0;
+                        }
+                    }
+                if (inc_fee > 0) {
+                    let max_possible_fee = util.BTC_to_Sat(new_fee) - inc_fee; //in satoshi
+                    return reject(`Insufficient output values to increase fee. Maximum fee possible: ${util.Sat_to_BTC(max_possible_fee)}`);
+                }
+                tx.outs = tx.outs.filter(o => o.value >= DUST_AMT); //remove all output with value less than DUST amount
+
+                //remove existing signatures and reset the scripts
+                let wif_keys = [];
+                let witness_position = 0;
+                for (let i in tx.ins) {
+                    var addr = tx_parsed.inputs[i].address,
+                        value = util.BTC_to_Sat(tx_parsed.inputs[i].value);
+                    let addr_decode = coinjs.addressDecode(addr);
+
+                    //find the correct key for addr
+                    var privKey = private_keys.find(pk => verifyKey(addr, pk));
+                    if (!privKey)
+                        return reject(`Private key missing for ${addr}`);
+                    //find redeemScript (if any)
+                    const rs = _redeemScript(addr, privKey);
+                    rs === false ? wif_keys.unshift(privKey) : wif_keys.push(privKey); //sorting private-keys (wif)
+                    //reset the script for re-signing
+                    var script;
+                    if (!rs || !rs.length) {
+                        //legacy script (derive from address)
+                        let s = coinjs.script();
+                        s.writeOp(118); //OP_DUP
+                        s.writeOp(169); //OP_HASH160
+                        s.writeBytes(addr_decode.bytes);
+                        s.writeOp(136); //OP_EQUALVERIFY
+                        s.writeOp(172); //OP_CHECKSIG
+                        script = Crypto.util.bytesToHex(s.buffer);
+                    } else if (((rs.match(/^00/) && rs.length == 44)) || (rs.length == 40 && rs.match(/^[a-f0-9]+$/gi))) {
+                        //redeemScript for segwit/bech32 
+                        let s = coinjs.script();
+                        s.writeBytes(Crypto.util.hexToBytes(rs));
+                        s.writeOp(0);
+                        s.writeBytes(coinjs.numToBytes(value.toFixed(0), 8));
+                        script = Crypto.util.bytesToHex(s.buffer);
+                        if (addr_decode == "bech32") {witness_position = witness_position + 1;} //bech32 has witness
+                    } else if (addr_decode.type === 'multisigBech32') {
+                        var rs_array = [];
+                        rs_array = btcOperator.extractLastHexStrings(tx.witness);
+                        let redeemScript = rs_array[witness_position];
+                        witness_position = witness_position + 1;
+                   
+                        //redeemScript multisig (bech32)
+                        let s = coinjs.script();
+                        s.writeBytes(Crypto.util.hexToBytes(redeemScript));
+                        s.writeOp(0);
+                        s.writeBytes(coinjs.numToBytes(value.toFixed(0), 8));
+                        script = Crypto.util.bytesToHex(s.buffer);
+                    } else //redeemScript for multisig (segwit)
+                        script = rs;
+                    tx.ins[i].script = coinjs.script(script);
+                }
+                tx.witness = false; //remove all witness signatures
+                console.debug("Unsigned:", tx.serialize());
+                //re-sign the transaction
+                new Set(wif_keys).forEach(key => tx.sign(key, 1 /*sighashtype*/ )); //Sign the tx using private key WIF
+                if (btcOperator.checkSigned(tx)) {
+                      resolve(tx.serialize());
+                    } else {
+                      reject("All private keys not present");
+                    }
+            }).catch(error => reject(error))
+        }).catch(error => reject(error))
+    })
+}
+
+
     btcOperator.sendTx = function (senders, privkeys, receivers, amounts, fee = null, options = {}) {
         return new Promise((resolve, reject) => {
             createSignedTx(senders, privkeys, receivers, amounts, fee, options).then(result => {
-                debugger;
+                // debugger;
                 broadcastTx(result.transaction.serialize())
                     .then(txid => resolve(txid))
                     .catch(error => reject(error));
@@ -760,7 +899,7 @@
         })
     }
 
-    function deserializeTx(tx) {
+    const deserializeTx = btcOperator.deserializeTx = function (tx) {
         if (typeof tx === 'string' || Array.isArray(tx)) {
             try {
                 tx = coinjs.transaction().deserialize(tx);
@@ -905,7 +1044,7 @@
         }).catch(error => reject(error))
     });
 
-    getTx.hex = txid => new Promise((resolve, reject) => {
+    getTx.hex = btcOperator.getTx.hex = txid => new Promise((resolve, reject) => {
         fetch_api(`rawtx/${txid}?format=hex`, false)
             .then(result => resolve(result))
             .catch(error => reject(error))

floBlockchainAPI.js

@@ -1,13 +1,13 @@
-(function (EXPORTS) { //floBlockchainAPI v2.5.6b
+(function (EXPORTS) { //floBlockchainAPI v3.0.1b
-    /* FLO Blockchain Operator to send/receive data from blockchain using API calls*/
+    /* FLO Blockchain Operator to send/receive data from blockchain using API calls via FLO Blockbook*/
     'use strict';
     const floBlockchainAPI = EXPORTS;
 
     const DEFAULT = {
         blockchain: floGlobals.blockchain,
         apiURL: {
-            FLO: ['https://flosight.ranchimall.net/'],
+            FLO: ['https://blockbook.ranchimall.net/'],
-            FLO_TEST: ['https://flosight-testnet.ranchimall.net/']
+            FLO_TEST: ['https://blockbook-testnet.ranchimall.net/']
         },
         sendAmt: 0.0003,
         fee: 0.0002,
@@ -61,9 +61,9 @@
     var serverList = Array.from(allServerList);
     var curPos = floCrypto.randInt(0, serverList.length - 1);
 
-    function fetch_retry(apicall, rm_flosight) {
+    function fetch_retry(apicall, rm_node) {
         return new Promise((resolve, reject) => {
-            let i = serverList.indexOf(rm_flosight)
+            let i = serverList.indexOf(rm_node)
             if (i != -1) serverList.splice(i, 1);
             curPos = floCrypto.randInt(0, serverList.length - 1);
             fetch_api(apicall, false)
@@ -82,19 +82,19 @@
                         .then(result => resolve(result))
                         .catch(error => reject(error));
                 } else
-                    reject("No floSight server working");
+                    reject("No FLO blockbook server working");
             } else {
-                let flosight = serverList[curPos];
+                let serverURL = serverList[curPos];
-                fetch(flosight + apicall).then(response => {
+                fetch(serverURL + apicall).then(response => {
                     if (response.ok)
                         response.json().then(data => resolve(data));
                     else {
-                        fetch_retry(apicall, flosight)
+                        fetch_retry(apicall, serverURL)
                             .then(result => resolve(result))
                             .catch(error => reject(error));
                     }
                 }).catch(error => {
-                    fetch_retry(apicall, flosight)
+                    fetch_retry(apicall, serverURL)
                         .then(result => resolve(result))
                         .catch(error => reject(error));
                 })
@@ -124,43 +124,27 @@
     }
 
     //Get balance for the given Address
-    const getBalance = floBlockchainAPI.getBalance = function (addr, after = null) {
+    const getBalance = floBlockchainAPI.getBalance = function (addr) {
         return new Promise((resolve, reject) => {
-            let api = `api/addr/${addr}/balance`, query_params = {};
+            let api = `api/address/${addr}`;
-            if (after) {
+            promisedAPI(api, { details: "basic" })
-                if (typeof after === 'string' && /^[0-9a-z]{64}$/i.test(after))
+                .then(result => resolve(result["balance"]))
-                    query_params.after = after;
+                .catch(error => reject(error))
-                else return reject("Invalid 'after' parameter");
-            }
-            promisedAPI(api, query_params).then(result => {
-                if (typeof result === 'object' && result.lastItem) {
-                    getBalance(addr, result.lastItem)
-                        .then(r => resolve(util.toFixed(r + result.data)))
-                        .catch(error => reject(error))
-                } else resolve(result);
-            }).catch(error => reject(error))
         });
     }
 
-    const getUTXOs = address => new Promise((resolve, reject) => {
+    function getScriptPubKey(address) {
-        promisedAPI(`api/addr/${address}/utxo`)
+        var tx = bitjs.transaction();
-            .then(utxo => resolve(utxo))
+        tx.addoutput(address, 0);
-            .catch(error => reject(error))
+        let outputBuffer = tx.outputs.pop().script;
-    })
+        return Crypto.util.bytesToHex(outputBuffer)
+    }
 
-    const getUnconfirmedSpent = address => new Promise((resolve, reject) => {
+    const getUTXOs = address => new Promise((resolve, reject) => {
-        readTxs(address, { mempool: "only" }).then(result => {
+        promisedAPI(`api/utxo/${address}`, { confirmed: true }).then(utxos => {
-            let unconfirmedSpent = {};
+            let scriptPubKey = getScriptPubKey(address);
-            for (let tx of result.items)
+            utxos.forEach(u => u.scriptPubKey = scriptPubKey);
-                if (tx.confirmations == 0)
+            resolve(utxos);
-                    for (let vin of tx.vin)
-                        if (vin.addr === address) {
-                            if (Array.isArray(unconfirmedSpent[vin.txid]))
-                                unconfirmedSpent[vin.txid].push(vin.vout);
-                            else
-                                unconfirmedSpent[vin.txid] = [vin.vout];
-                        }
-            resolve(unconfirmedSpent);
         }).catch(error => reject(error))
     })
 
@@ -180,32 +164,28 @@
                 var fee = DEFAULT.fee;
                 if (balance < sendAmt + fee)
                     return reject("Insufficient FLO balance!");
-                getUnconfirmedSpent(senderAddr).then(unconfirmedSpent => {
+                getUTXOs(senderAddr).then(utxos => {
-                    getUTXOs(senderAddr).then(utxos => {
+                    //form/construct the transaction data
-                        //form/construct the transaction data
+                    var trx = bitjs.transaction();
-                        var trx = bitjs.transaction();
+                    var utxoAmt = 0.0;
-                        var utxoAmt = 0.0;
+                    for (var i = utxos.length - 1;
-                        for (var i = utxos.length - 1;
+                        (i >= 0) && (utxoAmt < sendAmt + fee); i--) {
-                            (i >= 0) && (utxoAmt < sendAmt + fee); i--) {
+                        //use only utxos with confirmations (strict_utxo mode)
-                            //use only utxos with confirmations (strict_utxo mode)
+                        if (utxos[i].confirmations || !strict_utxo) {
-                            if (utxos[i].confirmations || !strict_utxo) {
+                            trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i].scriptPubKey);
-                                if (utxos[i].txid in unconfirmedSpent && unconfirmedSpent[utxos[i].txid].includes(utxos[i].vout))
+                            utxoAmt += utxos[i].amount;
-                                    continue; //A transaction has already used the 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: Some UTXOs are unconfirmed");
-                        }
+                    else {
-                        if (utxoAmt < sendAmt + fee)
+                        trx.addoutput(receiverAddr, sendAmt);
-                            reject("Insufficient FLO: Some UTXOs are unconfirmed");
+                        var change = utxoAmt - sendAmt - fee;
-                        else {
+                        if (change > DEFAULT.minChangeAmt)
-                            trx.addoutput(receiverAddr, sendAmt);
+                            trx.addoutput(senderAddr, change);
-                            var change = utxoAmt - sendAmt - fee;
+                        trx.addflodata(floData.replace(/\n/g, ' '));
-                            if (change > DEFAULT.minChangeAmt)
+                        resolve(trx);
-                                trx.addoutput(senderAddr, change);
+                    }
-                            trx.addflodata(floData.replace(/\n/g, ' '));
-                            resolve(trx);
-                        }
-                    }).catch(error => reject(error))
                 }).catch(error => reject(error))
             }).catch(error => reject(error))
         })
@@ -293,34 +273,30 @@
                 if (balance < totalAmt + fee)
                     return reject("Insufficient FLO balance!");
                 //get unconfirmed tx list
-                getUnconfirmedSpent(floID).then(unconfirmedSpent => {
+                getUTXOs(floID).then(utxos => {
-                    getUTXOs(floID).then(utxos => {
+                    var trx = bitjs.transaction();
-                        var trx = bitjs.transaction();
+                    var utxoAmt = 0.0;
-                        var utxoAmt = 0.0;
+                    for (let i = utxos.length - 1; (i >= 0) && (utxoAmt < totalAmt + fee); i--) {
-                        for (let i = utxos.length - 1; (i >= 0) && (utxoAmt < totalAmt + fee); i--) {
+                        //use only utxos with confirmations (strict_utxo mode)
-                            //use only utxos with confirmations (strict_utxo mode)
+                        if (utxos[i].confirmations || !strict_utxo) {
-                            if (utxos[i].confirmations || !strict_utxo) {
+                            trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i].scriptPubKey);
-                                if (utxos[i].txid in unconfirmedSpent && unconfirmedSpent[utxos[i].txid].includes(utxos[i].vout))
+                            utxoAmt += utxos[i].amount;
-                                    continue; //A transaction has already used the utxo, but is unconfirmed.
+                        };
-                                trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i].scriptPubKey);
+                    }
-                                utxoAmt += utxos[i].amount;
+                    if (utxoAmt < totalAmt + fee)
-                            };
+                        reject("Insufficient FLO: Some UTXOs are unconfirmed");
-                        }
+                    else {
-                        if (utxoAmt < totalAmt + fee)
+                        for (let i = 0; i < count; i++)
-                            reject("Insufficient FLO: Some UTXOs are unconfirmed");
+                            trx.addoutput(floID, splitAmt);
-                        else {
+                        var change = utxoAmt - totalAmt - fee;
-                            for (let i = 0; i < count; i++)
+                        if (change > DEFAULT.minChangeAmt)
-                                trx.addoutput(floID, splitAmt);
+                            trx.addoutput(floID, change);
-                            var change = utxoAmt - totalAmt - fee;
+                        trx.addflodata(floData.replace(/\n/g, ' '));
-                            if (change > DEFAULT.minChangeAmt)
+                        var signedTxHash = trx.sign(privKey, 1);
-                                trx.addoutput(floID, change);
+                        broadcastTx(signedTxHash)
-                            trx.addflodata(floData.replace(/\n/g, ' '));
+                            .then(txid => resolve(txid))
-                            var signedTxHash = trx.sign(privKey, 1);
+                            .catch(error => reject(error))
-                            broadcastTx(signedTxHash)
+                    }
-                                .then(txid => resolve(txid))
-                                .catch(error => reject(error))
-                        }
-                    }).catch(error => reject(error))
                 }).catch(error => reject(error))
             }).catch(error => reject(error))
         })
@@ -551,33 +527,29 @@
                 var fee = DEFAULT.fee;
                 if (balance < sendAmt + fee)
                     return reject("Insufficient FLO balance!");
-                getUnconfirmedSpent(senderAddr).then(unconfirmedSpent => {
+                getUTXOs(senderAddr).then(utxos => {
-                    getUTXOs(senderAddr).then(utxos => {
+                    //form/construct the transaction data
-                        //form/construct the transaction data
+                    var trx = bitjs.transaction();
-                        var trx = bitjs.transaction();
+                    var utxoAmt = 0.0;
-                        var utxoAmt = 0.0;
+                    for (var i = utxos.length - 1;
-                        for (var i = utxos.length - 1;
+                        (i >= 0) && (utxoAmt < sendAmt + fee); i--) {
-                            (i >= 0) && (utxoAmt < sendAmt + fee); i--) {
+                        //use only utxos with confirmations (strict_utxo mode)
-                            //use only utxos with confirmations (strict_utxo mode)
+                        if (utxos[i].confirmations || !strict_utxo) {
-                            if (utxos[i].confirmations || !strict_utxo) {
+                            trx.addinput(utxos[i].txid, utxos[i].vout, redeemScript); //for multisig, script=redeemScript
-                                if (utxos[i].txid in unconfirmedSpent && unconfirmedSpent[utxos[i].txid].includes(utxos[i].vout))
+                            utxoAmt += utxos[i].amount;
-                                    continue; //A transaction has already used the utxo, but is unconfirmed.
+                        };
-                                trx.addinput(utxos[i].txid, utxos[i].vout, redeemScript); //for multisig, script=redeemScript
+                    }
-                                utxoAmt += utxos[i].amount;
+                    if (utxoAmt < sendAmt + fee)
-                            };
+                        reject("Insufficient FLO: Some UTXOs are unconfirmed");
-                        }
+                    else {
-                        if (utxoAmt < sendAmt + fee)
+                        for (let i in receivers)
-                            reject("Insufficient FLO: Some UTXOs are unconfirmed");
+                            trx.addoutput(receivers[i], amounts[i]);
-                        else {
+                        var change = utxoAmt - sendAmt - fee;
-                            for (let i in receivers)
+                        if (change > DEFAULT.minChangeAmt)
-                                trx.addoutput(receivers[i], amounts[i]);
+                            trx.addoutput(senderAddr, change);
-                            var change = utxoAmt - sendAmt - fee;
+                        trx.addflodata(floData.replace(/\n/g, ' '));
-                            if (change > DEFAULT.minChangeAmt)
+                        resolve(trx);
-                                trx.addoutput(senderAddr, change);
+                    }
-                            trx.addflodata(floData.replace(/\n/g, ' '));
-                            resolve(trx);
-                        }
-                    }).catch(error => reject(error))
                 }).catch(error => reject(error))
             }).catch(error => reject(error))
         });
@@ -773,20 +745,11 @@
     const broadcastTx = floBlockchainAPI.broadcastTx = function (signedTxHash) {
         return new Promise((resolve, reject) => {
             if (signedTxHash.length < 1)
-                return reject("Empty Signature");
+                return reject("Empty Transaction Data");
-            var url = serverList[curPos] + 'api/tx/send';
+
-            fetch(url, {
+            promisedAPI('/api/sendtx/' + signedTxHash)
-                method: "POST",
+                .then(response => resolve(response["result"]))
-                headers: {
+                .catch(error => reject(error))
-                    'Content-Type': 'application/json'
-                },
-                body: `{"rawtx":"${signedTxHash}"}`
-            }).then(response => {
-                if (response.ok)
-                    response.json().then(data => resolve(data.txid.result));
-                else
-                    response.text().then(data => resolve(data));
-            }).catch(error => reject(error));
         })
     }
 
@@ -825,61 +788,96 @@
         })
     }
 
-    //Read Txs of Address between from and to
+    //Read Txs of Address
     const readTxs = floBlockchainAPI.readTxs = function (addr, options = {}) {
         return new Promise((resolve, reject) => {
-            let api = `api/addrs/${addr}/txs`;
             //API options
-            let query_params = {};
+            let query_params = { details: 'txs' };
-            if (!isUndefined(options.after) || !isUndefined(options.before)) {
+            //page options
-                if (!isUndefined(options.after))
+            if (!isUndefined(options.page) && Number.isInteger(options.page))
-                    query_params.after = options.after;
+                query_params.page = options.page;
-                if (!isUndefined(options.before))
+            if (!isUndefined(options.pageSize) && Number.isInteger(options.pageSize))
-                    query_params.before = options.before;
+                query_params.pageSize = options.pageSize;
-            } else {
+            //only confirmed tx
-                if (!isUndefined(options.from))
+            if (options.confirmed)  //Default is false in server, so only add confirmed filter if confirmed has a true value
-                    query_params.from = options.from;
+                query_params.confirmed = true;
-                if (!isUndefined(options.to))
+
-                    query_params.to = options.to;
+            promisedAPI(`api/address/${addr}`, query_params).then(response => {
-            }
+                if (!Array.isArray(response.txs))    //set empty array if address doesnt have any tx
-            if (!isUndefined(options.latest))
+                    response.txs = [];
-                query_params.latest = options.latest;
+                resolve(response)
-            if (!isUndefined(options.mempool))
+            }).catch(error => reject(error))
-                query_params.mempool = options.mempool;
-            promisedAPI(api, query_params)
-                .then(response => resolve(response))
-                .catch(error => reject(error))
         });
     }
 
+    //backward support (floBlockchainAPI < v2.5.6)
+    function readAllTxs_oldSupport(addr, options, ignoreOld = 0, cacheTotal = 0) {
+        return new Promise((resolve, reject) => {
+            readTxs(addr, options).then(response => {
+                cacheTotal += response.txs.length;
+                let n_remaining = response.txApperances - cacheTotal
+                if (n_remaining < ignoreOld) { // must remove tx that would have been fetch during prev call
+                    let n_remove = ignoreOld - n_remaining;
+                    resolve(response.txs.slice(0, -n_remove));
+                } else if (response.page == response.totalPages) //last page reached
+                    resolve(response.txs);
+                else {
+                    options.page = response.page + 1;
+                    readAllTxs_oldSupport(addr, options, ignoreOld, cacheTotal)
+                        .then(result => resolve(response.txs.concat(result)))
+                        .catch(error => reject(error))
+                }
+            }).catch(error => reject(error))
+        })
+    }
+
+    function readAllTxs_new(addr, options, lastItem) {
+        return new Promise((resolve, reject) => {
+            readTxs(addr, options).then(response => {
+                let i = response.txs.findIndex(t => t.txid === lastItem);
+                if (i != -1)  //found lastItem
+                    resolve(response.txs.slice(0, i))
+                else if (response.page == response.totalPages) //last page reached
+                    resolve(response.txs);
+                else {
+                    options.page = response.page + 1;
+                    readAllTxs_new(addr, options, lastItem)
+                        .then(result => resolve(response.txs.concat(result)))
+                        .catch(error => reject(error))
+                }
+            }).catch(error => reject(error))
+        })
+    }
+
     //Read All Txs of Address (newest first)
     const readAllTxs = floBlockchainAPI.readAllTxs = function (addr, options = {}) {
         return new Promise((resolve, reject) => {
-            readTxs(addr, options).then(response => {
+            if (Number.isInteger(options.ignoreOld)) //backward support: data from floBlockchainAPI < v2.5.6
-                if (response.incomplete) {
+                readAllTxs_oldSupport(addr, options, options.ignoreOld).then(txs => {
-                    let next_options = Object.assign({}, options);
+                    let last_tx = txs.find(t => t.confirmations > 0);
-                    if (options.latest)
+                    let new_lastItem = last_tx ? last_tx.txid : options.ignoreOld;
-                        next_options.before = response.initItem; //update before for chain query (latest 1st)
-                    else
-                        next_options.after = response.lastItem; //update after for chain query (oldest 1st)
-                    readAllTxs(addr, next_options).then(r => {
-                        r.items = r.items.concat(response.items);   //latest tx are 1st in array
-                        resolve(r);
-                    }).catch(error => reject(error))
-                } else
                     resolve({
-                        lastItem: response.lastItem || options.after,
+                        lastItem: new_lastItem,
-                        items: response.items
+                        items: txs
-                    });
+                    })
-            })
+
-        });
+                }).catch(error => reject(error))
+            else    //New format for floBlockchainAPI >= v2.5.6
+                readAllTxs_new(addr, options, options.after).then(txs => {
+                    let last_tx = txs.find(t => t.confirmations > 0);
+                    let new_lastItem = last_tx ? last_tx.txid : options.after;
+                    resolve({
+                        lastItem: new_lastItem,
+                        items: txs
+                    })
+                }).catch(error => reject(error))
+        })
     }
 
     /*Read flo Data from txs of given Address
     options can be used to filter data
     after       : query after the given txid
-    before      : query before the given txid
+    confirmed   : query only confirmed tx or not (options same as readAllTx, DEFAULT=true: only_confirmed_tx)
-    mempool     : query mempool tx or not (options same as readAllTx, DEFAULT=false: ignore unconfirmed tx)
     ignoreOld   : ignore old txs (deprecated: support for backward compatibility only, cannot be used with 'after')
     sentOnly    : filters only sent data
     receivedOnly: filters only received data
@@ -894,18 +892,14 @@
 
             //fetch options
             let query_options = {};
-            query_options.mempool = isUndefined(options.mempool) ? false : options.mempool; //DEFAULT: ignore unconfirmed tx
+            query_options.confirmed = isUndefined(options.confirmed) ? true : options.confirmed; //DEFAULT: ignore unconfirmed tx
-            if (!isUndefined(options.after) || !isUndefined(options.before)) {
-                if (!isUndefined(options.ignoreOld)) //Backward support
-                    return reject("Invalid options: cannot use after/before and ignoreOld in same query");
-                //use passed after and/or before options (options remain undefined if not passed)
-                query_options.after = options.after;
-                query_options.before = options.before;
-            }
-            readAllTxs(addr, query_options).then(response => {
 
-                if (Number.isInteger(options.ignoreOld))  //backward support, cannot be used with options.after or options.before
+            if (!isUndefined(options.after))
-                    response.items.splice(-options.ignoreOld);   //negative to count from end of the array
+                query_options.after = options.after;
+            else if (!isUndefined(options.ignoreOld))
+                query_options.ignoreOld = options.ignoreOld;
+
+            readAllTxs(addr, query_options).then(response => {
 
                 if (typeof options.senders === "string") options.senders = [options.senders];
                 if (typeof options.receivers === "string") options.receivers = [options.receivers];
@@ -916,9 +910,9 @@
                     if (!tx.confirmations)  //unconfirmed transactions: this should not happen as we send mempool=false in API query
                         return false;
 
-                    if (options.sentOnly && !tx.vin.some(vin => vin.addr === addr))
+                    if (options.sentOnly && !tx.vin.some(vin => vin.addresses[0] === addr))
                         return false;
-                    else if (Array.isArray(options.senders) && !tx.vin.some(vin => options.senders.includes(vin.addr)))
+                    else if (Array.isArray(options.senders) && !tx.vin.some(vin => options.senders.includes(vin.addresses[0])))
                         return false;
 
                     if (options.receivedOnly && !tx.vout.some(vout => vout.scriptPubKey.addresses[0] === addr))
@@ -944,7 +938,7 @@
                     txid: tx.txid,
                     time: tx.time,
                     blockheight: tx.blockheight,
-                    senders: new Set(tx.vin.map(v => v.addr)),
+                    senders: new Set(tx.vin.map(v => v.addresses[0])),
                     receivers: new Set(tx.vout.map(v => v.scriptPubKey.addresses[0])),
                     data: tx.floData
                 } : tx.floData);
@@ -964,8 +958,7 @@
     caseFn: (function) flodata => return bool value
     options can be used to filter data
     after       : query after the given txid
-    before      : query before the given txid
+    confirmed   : query only confirmed tx or not (options same as readAllTx, DEFAULT=true: only_confirmed_tx)
-    mempool     : query mempool tx or not (options same as readAllTx, DEFAULT=false: ignore unconfirmed tx)
     sentOnly    : filters only sent data
     receivedOnly: filters only received data
     tx          : (boolean) resolve tx data or not (resolves an Array of Object with tx details)
@@ -975,23 +968,37 @@
     const getLatestData = floBlockchainAPI.getLatestData = function (addr, caseFn, options = {}) {
         return new Promise((resolve, reject) => {
             //fetch options
-            let query_options = { latest: true };
+            let query_options = {};
-            query_options.mempool = isUndefined(options.mempool) ? false : options.mempool; //DEFAULT: ignore unconfirmed tx
+            query_options.confirmed = isUndefined(options.confirmed) ? true : options.confirmed; //DEFAULT: confirmed tx only
-            if (!isUndefined(options.after)) query_options.after = options.after;
+            if (!isUndefined(options.page))
-            if (!isUndefined(options.before)) query_options.before = options.before;
+                query_options.page = options.page;
+            //if (!isUndefined(options.after)) query_options.after = options.after;
 
+            let new_lastItem;
             readTxs(addr, query_options).then(response => {
 
+                //lastItem confirmed tx checked
+                if (!new_lastItem) {
+                    let last_tx = response.items.find(t => t.confirmations > 0);
+                    if (last_tx)
+                        new_lastItem = last_tx.txid;
+                }
+
                 if (typeof options.senders === "string") options.senders = [options.senders];
                 if (typeof options.receivers === "string") options.receivers = [options.receivers];
 
+                //check if `after` txid is in the response
+                let i_after = response.txs.findIndex(t => t.txid === options.after);
+                if (i_after != -1)  //found lastItem, hence remove it and all txs before that
+                    response.items.splice(i_after);
+
                 var item = response.items.find(tx => {
                     if (!tx.confirmations)  //unconfirmed transactions: this should not happen as we send mempool=false in API query
                         return false;
 
-                    if (options.sentOnly && !tx.vin.some(vin => vin.addr === addr))
+                    if (options.sentOnly && !tx.vin.some(vin => vin.addresses[0] === addr))
                         return false;
-                    else if (Array.isArray(options.senders) && !tx.vin.some(vin => options.senders.includes(vin.addr)))
+                    else if (Array.isArray(options.senders) && !tx.vin.some(vin => options.senders.includes(vin.addresses[0])))
                         return false;
 
                     if (options.receivedOnly && !tx.vout.some(vout => vout.scriptPubKey.addresses[0] === addr))
@@ -1004,35 +1011,34 @@
 
                 //if item found, then resolve the result
                 if (!isUndefined(item)) {
-                    const result = { lastItem: response.lastItem };
+                    const result = { lastItem: new_lastItem || item.txid };
                     if (options.tx) {
                         result.item = {
-                            txid: tx.txid,
+                            txid: item.txid,
-                            time: tx.time,
+                            time: item.time,
-                            blockheight: tx.blockheight,
+                            blockheight: item.blockheight,
-                            senders: new Set(tx.vin.map(v => v.addr)),
+                            senders: new Set(item.vin.map(v => v.addresses[0])),
-                            receivers: new Set(tx.vout.map(v => v.scriptPubKey.addresses[0])),
+                            receivers: new Set(item.vout.map(v => v.scriptPubKey.addresses[0])),
-                            data: tx.floData
+                            data: item.floData
                         }
                     } else
-                        result.data = tx.floData;
+                        result.data = item.floData;
                     return resolve(result);
                 }
+
+                if (response.page == response.totalPages || i_after != -1) //reached last page to check 
+                    resolve({ lastItem: new_lastItem || options.after }); //no data match the caseFn, resolve just the lastItem
+
                 //else if address needs chain query
-                else if (response.incomplete) {
+                else {
-                    let next_options = Object.assign({}, options);
+                    options.page = response.page + 1;
-                    options.before = response.initItem; //this fn uses latest option, so using before to chain query
+                    getLatestData(addr, caseFn, options)
-                    getLatestData(addr, caseFn, next_options).then(r => {
+                        .then(result => resolve(result))
-                        r.lastItem = response.lastItem;  //update last key as it should be the newest tx
+                        .catch(error => reject(error))
-                        resolve(r);
-                    }).catch(error => reject(error))
                 }
-                //no data match the caseFn, resolve just the lastItem
-                else
-                    resolve({ lastItem: response.lastItem });
 
             }).catch(error => reject(error))
         })
     }
 
-})('object' === typeof module ? module.exports : window.floBlockchainAPI = {});
+})('object' === typeof module ? module.exports : window.floBlockchainAPI = {});

floCloudAPI.js

@@ -1,4 +1,4 @@
-(function (EXPORTS) { //floCloudAPI v2.4.3a
+(function (EXPORTS) { //floCloudAPI v2.4.5
     /* FLO Cloud operations to send/request application data*/
     'use strict';
     const floCloudAPI = EXPORTS;
@@ -609,49 +609,39 @@
         })
     }
     */
-    /*(NEEDS UPDATE)
+    //edit comment of data in supernode cloud (sender only)
-    //edit comment of data in supernode cloud (mutable comments only)
+    floCloudAPI.editApplicationData = function (vectorClock, comment_edit, options = {}) {
-    floCloudAPI.editApplicationData = function(vectorClock, newComment, oldData, options = {}) {
         return new Promise((resolve, reject) => {
-            let p0
+            //request the data from cloud for resigning
-            if (!oldData) {
+            let req_options = Object.assign({}, options);
-                options.atVectorClock = vectorClock;
+            req_options.atVectorClock = vectorClock;
-                options.callback = false;
+            requestApplicationData(undefined, req_options).then(result => {
-                p0 = requestApplicationData(false, options)
+                if (!result.length)
-            } else
+                    return reject("Data not found");
-                p0 = Promise.resolve({
+                let data = result[0];
-                    vectorClock: {
+                if (data.senderID !== user.id)
-                        ...oldData
+                    return reject("Only sender can edit comment");
-                    }
+                data.comment = comment_edit;
-                })
+                let hashcontent = ["receiverID", "time", "application", "type", "message", "comment"]
-            p0.then(d => {
+                    .map(d => data[d]).join("|");
-                if (d.senderID != user.id)
+                let re_sign = user.sign(hashcontent);
-                    return reject("Invalid requestorID")
+                var request = {
-                else if (!d.comment.startsWith("EDIT:"))
+                    receiverID: options.receiverID || DEFAULT.adminID,
-                    return reject("Data immutable")
-                let data = {
                     requestorID: user.id,
-                    receiverID: d.receiverID,
+                    pubKey: user.public,
                     time: Date.now(),
-                    application: d.application,
+                    vectorClock: vectorClock,
-                    edit: {
+                    edit: comment_edit,
-                        vectorClock: vectorClock,
+                    re_sign: re_sign
-                        comment: newComment
-                    }
                 }
-                d.comment = data.edit.comment;
+                let request_hash = ["time", "vectorClock", "edit", "re_sign"].map(d => request[d]).join("|");
-                let hashcontent = ["receiverID", "time", "application", "type", "message",
+                request.sign = user.sign(request_hash);
-                        "comment"
+                singleRequest(request.receiverID, request)
-                    ]
+                    .then(result => resolve(result))
-                    .map(x => d[x]).join("|")
-                data.edit.sign = user.sign(hashcontent)
-                singleRequest(data.receiverID, data)
-                    .then(result => resolve("Data comment updated"))
                     .catch(error => reject(error))
-            })
+            }).catch(error => reject(error))
         })
     }
-    */
 
     //tag data in supernode cloud (subAdmin access only)
     floCloudAPI.tagApplicationData = function (vectorClock, tag, options = {}) {
@@ -811,6 +801,67 @@
         })
     }
 
+    //upload file
+    floCloudAPI.uploadFile = function (fileBlob, type, options = {}) {
+        return new Promise((resolve, reject) => {
+            if (!(fileBlob instanceof File) && !(fileBlob instanceof Blob))
+                return reject("file must be instance of File/Blob");
+            fileBlob.arrayBuffer().then(arraybuf => {
+                let file_data = { type: fileBlob.type, name: fileBlob.name };
+                file_data.content = Crypto.util.bytesToBase64(new Uint8Array(arraybuf));
+                if (options.encrypt) {
+                    let encryptionKey = options.encrypt === true ?
+                        floGlobals.settings.encryptionKey : options.encrypt
+                    file_data = floCrypto.encryptData(JSON.stringify(file_data), encryptionKey)
+                }
+                sendApplicationData(file_data, type, options)
+                    .then(({ vectorClock, receiverID, type, application }) => resolve({ vectorClock, receiverID, type, application }))
+                    .catch(error => reject(error))
+            }).catch(error => reject(error))
+        })
+    }
+
+    //download file
+    floCloudAPI.downloadFile = function (vectorClock, options = {}) {
+        return new Promise((resolve, reject) => {
+            options.atVectorClock = vectorClock;
+            requestApplicationData(options.type, options).then(result => {
+                if (!result.length)
+                    return reject("File not found");
+                result = result[0];
+                try {
+                    let file_data = decodeMessage(result.message);
+                    //file is encrypted: decryption required
+                    if (file_data instanceof Object && "secret" in file_data) {
+                        if (!options.decrypt)
+                            return reject("Data is encrypted");
+                        let decryptionKey = (options.decrypt === true) ? Crypto.AES.decrypt(user_private, aes_key) : options.decrypt;
+                        if (!Array.isArray(decryptionKey))
+                            decryptionKey = [decryptionKey];
+                        let flag = false;
+                        for (let key of decryptionKey) {
+                            try {
+                                let tmp = floCrypto.decryptData(file_data, key);
+                                file_data = JSON.parse(tmp);
+                                flag = true;
+                                break;
+                            } catch (error) { }
+                        }
+                        if (!flag)
+                            return reject("Unable to decrypt file: Invalid private key");
+                    }
+                    //reconstruct the file
+                    let arraybuf = new Uint8Array(Crypto.util.base64ToBytes(file_data.content))
+                    result.file = new File([arraybuf], file_data.name, { type: file_data.type });
+                    resolve(result)
+                } catch (error) {
+                    console.error(error);
+                    reject("Data is not a file");
+                }
+            }).catch(error => reject(error))
+        })
+    }
+
     /*
     Functions:
     findDiff(original, updatedObj) returns an object with the added, deleted and updated differences  

floDapps.js

@@ -1,4 +1,4 @@
-(function (EXPORTS) { //floDapps v2.4.0
+(function (EXPORTS) { //floDapps v2.4.1
     /* General functions for FLO Dapps*/
     'use strict';
     const floDapps = EXPORTS;
@@ -172,12 +172,7 @@
                 //general
                 lastTx: {},
                 //supernode (cloud list)
-                supernodes: {
+                supernodes: {}
-                    indexes: {
-                        uri: null,
-                        pubKey: null
-                    }
-                }
             }
             var obs_a = {
                 //login credentials
@@ -257,7 +252,8 @@
         return new Promise((resolve, reject) => {
             if (!startUpOptions.cloud)
                 return resolve("No cloud for this app");
-            compactIDB.readData("lastTx", floCloudAPI.SNStorageID, DEFAULT.root).then(lastTx => {
+            const CLOUD_KEY = "floCloudAPI#" + floCloudAPI.SNStorageID;
+            compactIDB.readData("lastTx", CLOUD_KEY, DEFAULT.root).then(lastTx => {
                 var query_options = { sentOnly: true, pattern: floCloudAPI.SNStorageName };
                 if (typeof lastTx == 'number')  //lastTx is tx count (*backward support)
                     query_options.ignoreOld = lastTx;
@@ -265,25 +261,27 @@
                     query_options.after = lastTx;
                 //fetch data from flosight
                 floBlockchainAPI.readData(floCloudAPI.SNStorageID, query_options).then(result => {
-                    for (var i = result.data.length - 1; i >= 0; i--) {
+                    compactIDB.readData("supernodes", CLOUD_KEY, DEFAULT.root).then(nodes => {
-                        var content = JSON.parse(result.data[i])[floCloudAPI.SNStorageName];
+                        nodes = nodes || {};
-                        for (let sn in content.removeNodes)
+                        for (var i = result.data.length - 1; i >= 0; i--) {
-                            compactIDB.removeData("supernodes", sn, DEFAULT.root);
+                            var content = JSON.parse(result.data[i])[floCloudAPI.SNStorageName];
-                        for (let sn in content.newNodes)
+                            for (let sn in content.removeNodes)
-                            compactIDB.writeData("supernodes", content.newNodes[sn], sn, DEFAULT.root);
+                                delete nodes[sn];
-                        for (let sn in content.updateNodes)
+                            for (let sn in content.newNodes)
-                            compactIDB.readData("supernodes", sn, DEFAULT.root).then(r => {
+                                nodes[sn] = content.newNodes[sn];
-                                r = r || {}
+                            for (let sn in content.updateNodes)
-                                r.uri = content.updateNodes[sn];
+                                if (sn in nodes) //check if node is listed
-                                compactIDB.writeData("supernodes", r, sn, DEFAULT.root);
+                                    nodes[sn].uri = content.updateNodes[sn];
-                            });
+                        }
-                    }
+                        Promise.all([
-                    compactIDB.writeData("lastTx", result.lastItem, floCloudAPI.SNStorageID, DEFAULT.root);
+                            compactIDB.writeData("lastTx", result.lastItem, CLOUD_KEY, DEFAULT.root),
-                    compactIDB.readAllData("supernodes", DEFAULT.root).then(nodes => {
+                            compactIDB.writeData("supernodes", nodes, CLOUD_KEY, DEFAULT.root)
-                        floCloudAPI.init(nodes)
+                        ]).then(_ => {
-                            .then(result => resolve("Loaded Supernode list\n" + result))
+                            floCloudAPI.init(nodes)
-                            .catch(error => reject(error))
+                                .then(result => resolve("Loaded Supernode list\n" + result))
-                    })
+                                .catch(error => reject(error))
+                        }).catch(error => reject(error))
+                    }).catch(error => reject(error))
                 })
             }).catch(error => reject(error))
         })

index.html

@@ -6,9 +6,9 @@
     <script id="floGlobals">
         /* Constants for FLO blockchain operations !!Make sure to add this at beginning!! */
         const floGlobals = {
-            blockchain: "FLO",
+            blockchain: "FLO_TEST",
-            adminID: "FKAEdnPfjXLHSYwrXQu377ugN4tXU7VGdf",
+            adminID: "oKKHdK5uYAJ52U91sYsWhnEaEAAhZP779B",
-            application: "TEST_MODE",
+            application: "TEST_MODE_testnet",
         }
     </script>
     <script>
@@ -54,4 +54,4 @@
     (use console)
 </body>
 
-</html>
+</html>