Update floDapps.js

Updating offline error capabilities

.github/workflows/push-dappbundle.yml

@@ -0,0 +1,32 @@
+name: Workflow push to Dappbundle
+on: [push]
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Executing remote command
+        uses: appleboy/ssh-action@v1.0.0
+        with:
+          host: ${{ secrets.R_HOST }}
+          username: ${{ secrets.P_USERNAME }}
+          password: ${{ secrets.P_PASSWORD }}
+          port: ${{ secrets.SSH_PORT }}
+          script: |
+            if [ -d "${{ secrets.DEPLOYMENT_LOCATION}}/dappbundle" ]; then
+              echo "Folder exists. Skipping Git clone."
+            else
+              echo "Folder does not exist. Cloning repository..."
+              cd ${{ secrets.DEPLOYMENT_LOCATION}}/ && git clone https://github.com/ranchimall/dappbundle.git 
+            fi
+
+            if [ -d "${{ secrets.DEPLOYMENT_LOCATION}}/dappbundle/${{ github.event.repository.name }}" ]; then
+              echo "Repository exists. Remove folder "
+              rm -r "${{ secrets.DEPLOYMENT_LOCATION}}/dappbundle/${{ github.event.repository.name }}"
+            fi
+
+            echo "Cloning repository..."
+            cd ${{ secrets.DEPLOYMENT_LOCATION}}/dappbundle && git clone https://github.com/ranchimall/${{ github.event.repository.name }}
+
+            cd "${{ secrets.DEPLOYMENT_LOCATION}}/dappbundle/${{ github.event.repository.name }}" && rm -rf .gitattributes .git .github .gitignore
+            cd ${{ secrets.DEPLOYMENT_LOCATION}}/dappbundle/ && git add . && git commit -m "Workflow updating files of ${{ github.event.repository.name }}" && git push "https://ranchimalldev:${{ secrets.RM_ACCESS_TOKEN }}@github.com/ranchimall/dappbundle.git"

.gitignore

@@ -1,2 +1,3 @@
 playground/
-combo.html
+combo.html
+*.tmp*

README.md

@@ -1,19 +1,26 @@
 # p2p-content-collaboration
 
-This is a peer to peer FLO Blockchain based content collaboration software that runs on a single HTML file. 
+This peer-to-peer FLO Blockchain-based content collaboration software runs on a single HTML file.  
+
+### Live URL for CC  
+*https://ranchimall.github.io/cc/*  
+
 
 ## How to run this software
 
 1. Download and run the HTML file on any browser (Google Chrome is preferred)
-2. It will ask for a FLO private key. If you do not have one please generate it from flo-webwallet.duckdns.org
-3. Once you provide your private keys you are logged in forever
-4. To add your suggestions please write inside the boxes under respective sections
-5. You can also chose to edit any content by adding/deleting contents
-6. To submit your views just click outside the box anywhere. Your views will be recorded
-7. The respective admins can score the content to choose the best ones
-8. To score the content please click on the star icon and provide a score. Score will be recorded.
+2. Or access the LIVE URL
+3. It will ask for a FLO private key. If you do not have one please generate it.
+4. Once you provide a correct private key you are logged in
+5. Inside the app, you can find the contents that are active
+6. To add your writeup please write inside the boxes under respective sections or subtopics
+7. You can also choose to edit any content by adding/deleting contents
+8. To submit your writeup click on the 'Submit' button. Your entries will be recorded
+9. The respective admins or sub-admins can score the content to choose the best ones
+10. To score the content, please click on the star icon and give a score. The score will be recorded. (Only authorized sub-admins can score content)
+11. Also you can download any content by selecting it and exporting it as a file.
 
-Any user running the file gets to edit a shared content. Hence, this application can be used for multiple purposes
-like create shared content, write book by multiple authors or reach a consensus through collaborative discussion.
+Any user running the file gets to edit shared content. Hence, this application can be used for multiple purposes
+like creating shared content, writing books by multiple authors, or reaching a consensus through collaborative discussion.
 
 Please fork the project and contribute.

package-lock.json

@@ -0,0 +1,13 @@
+{
+  "name": "p2p-content-collaboration",
+  "version": "1.0.0",
+  "lockfileVersion": 1,
+  "requires": true,
+  "dependencies": {
+    "tiny-editor": {
+      "version": "0.2.5",
+      "resolved": "https://registry.npmjs.org/tiny-editor/-/tiny-editor-0.2.5.tgz",
+      "integrity": "sha512-K4luWQbam/TrgjLst+Ztb7uPltXHwtFm+Oi1hs3xM6biI7N1X8HfyDtmROOEbyJM8+mMP5/FjsMnc96zJZoZCg=="
+    }
+  }
+}

package.json

@@ -0,0 +1,22 @@
+{
+  "name": "p2p-content-collaboration",
+  "version": "1.0.0",
+  "description": "",
+  "main": "components.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ranchimall/p2p-content-collaboration.git"
+  },
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/ranchimall/p2p-content-collaboration/issues"
+  },
+  "homepage": "https://github.com/ranchimall/p2p-content-collaboration#readme",
+  "dependencies": {
+    "tiny-editor": "^0.2.5"
+  }
+}

scripts/btcOperator.js

@@ -0,0 +1,996 @@
+(function (EXPORTS) { //btcOperator v1.1.3b
+    /* BTC Crypto and API Operator */
+    const btcOperator = EXPORTS;
+
+    //This library uses API provided by chain.so (https://chain.so/)
+    const URL = "https://blockchain.info/";
+
+    const DUST_AMT = 546,
+        MIN_FEE_UPDATE = 219;
+
+    const fetch_api = btcOperator.fetch = function (api, json_res = true) {
+        return new Promise((resolve, reject) => {
+            console.debug(URL + api);
+            fetch(URL + api).then(response => {
+                if (response.ok) {
+                    (json_res ? response.json() : response.text())
+                        .then(result => resolve(result))
+                        .catch(error => reject(error))
+                } else {
+                    response.json()
+                        .then(result => reject(result))
+                        .catch(error => reject(error))
+                }
+            }).catch(error => reject(error))
+        })
+    };
+
+    const SATOSHI_IN_BTC = 1e8;
+
+    const util = btcOperator.util = {};
+
+    util.Sat_to_BTC = value => parseFloat((value / SATOSHI_IN_BTC).toFixed(8));
+    util.BTC_to_Sat = value => parseInt(value * SATOSHI_IN_BTC);
+
+    function get_fee_rate() {
+        return new Promise((resolve, reject) => {
+            fetch('https://api.blockchain.info/mempool/fees').then(response => {
+                if (response.ok)
+                    response.json()
+                        .then(result => resolve(util.Sat_to_BTC(result.regular)))
+                        .catch(error => reject(error));
+                else
+                    reject(response);
+            }).catch(error => reject(error))
+        })
+    }
+
+    const broadcastTx = btcOperator.broadcastTx = rawTxHex => new Promise((resolve, reject) => {
+        let url = 'https://coinb.in/api/?uid=1&key=12345678901234567890123456789012&setmodule=bitcoin&request=sendrawtransaction';
+        fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded'
+            },
+            body: "rawtx=" + rawTxHex
+        }).then(response => {
+            response.text().then(resultText => {
+                let r = resultText.match(/<result>.*<\/result>/);
+                if (!r)
+                    reject(resultText);
+                else {
+                    r = r.pop().replace('<result>', '').replace('</result>', '');
+                    if (r == '1') {
+                        let txid = resultText.match(/<txid>.*<\/txid>/).pop().replace('<txid>', '').replace('</txid>', '');
+                        resolve(txid);
+                    } else if (r == '0') {
+                        let error = resultText.match(/<response>.*<\/response>/).pop().replace('<response>', '').replace('</response>', '');
+                        reject(decodeURIComponent(error.replace(/\+/g, " ")));
+                    } else reject(resultText);
+                }
+            }).catch(error => reject(error))
+        }).catch(error => reject(error))
+    });
+
+    Object.defineProperties(btcOperator, {
+        newKeys: {
+            get: () => {
+                let r = coinjs.newKeys();
+                r.segwitAddress = coinjs.segwitAddress(r.pubkey).address;
+                r.bech32Address = coinjs.bech32Address(r.pubkey).address;
+                return r;
+            }
+        },
+        pubkey: {
+            value: key => key.length >= 66 ? key : (key.length == 64 ? coinjs.newPubkey(key) : coinjs.wif2pubkey(key).pubkey)
+        },
+        address: {
+            value: (key, prefix = undefined) => coinjs.pubkey2address(btcOperator.pubkey(key), prefix)
+        },
+        segwitAddress: {
+            value: key => coinjs.segwitAddress(btcOperator.pubkey(key)).address
+        },
+        bech32Address: {
+            value: key => coinjs.bech32Address(btcOperator.pubkey(key)).address
+        }
+    });
+
+    coinjs.compressed = true;
+
+    const verifyKey = btcOperator.verifyKey = function (addr, key) {
+        if (!addr || !key)
+            return undefined;
+        switch (coinjs.addressDecode(addr).type) {
+            case "standard":
+                return btcOperator.address(key) === addr;
+            case "multisig":
+                return btcOperator.segwitAddress(key) === addr;
+            case "bech32":
+                return btcOperator.bech32Address(key) === addr;
+            default:
+                return null;
+        }
+    }
+
+    const validateAddress = btcOperator.validateAddress = function (addr) {
+        if (!addr)
+            return undefined;
+        let type = coinjs.addressDecode(addr).type;
+        if (["standard", "multisig", "bech32", "multisigBech32"].includes(type))
+            return type;
+        else
+            return false;
+    }
+
+    btcOperator.multiSigAddress = function (pubKeys, minRequired, bech32 = true) {
+        if (!Array.isArray(pubKeys))
+            throw "pubKeys must be an array of public keys";
+        else if (pubKeys.length < minRequired)
+            throw "minimum required should be less than the number of pubKeys";
+        if (bech32)
+            return coinjs.pubkeys2MultisigAddressBech32(pubKeys, minRequired);
+        else
+            return coinjs.pubkeys2MultisigAddress(pubKeys, minRequired);
+    }
+
+    btcOperator.decodeRedeemScript = function (redeemScript, bech32 = true) {
+        let script = coinjs.script();
+        let decoded = (bech32) ?
+            script.decodeRedeemScriptBech32(redeemScript) :
+            script.decodeRedeemScript(redeemScript);
+        if (!decoded)
+            return null;
+        return {
+            address: decoded.address,
+            pubKeys: decoded.pubkeys,
+            redeemScript: decoded.redeemscript,
+            required: decoded.signaturesRequired
+        }
+
+    }
+
+    //convert from one blockchain to another blockchain (target version)
+    btcOperator.convert = {};
+
+    btcOperator.convert.wif = function (source_wif, target_version = coinjs.priv) {
+        let keyHex = util.decodeLegacy(source_wif).hex;
+        if (!keyHex || keyHex.length < 66 || !/01$/.test(keyHex))
+            return null;
+        else
+            return util.encodeLegacy(keyHex, target_version);
+    }
+
+    btcOperator.convert.legacy2legacy = function (source_addr, target_version = coinjs.pub) {
+        let rawHex = util.decodeLegacy(source_addr).hex;
+        if (!rawHex)
+            return null;
+        else
+            return util.encodeLegacy(rawHex, target_version);
+    }
+
+    btcOperator.convert.legacy2bech = function (source_addr, target_version = coinjs.bech32.version, target_hrp = coinjs.bech32.hrp) {
+        let rawHex = util.decodeLegacy(source_addr).hex;
+        if (!rawHex)
+            return null;
+        else
+            return util.encodeBech32(rawHex, target_version, target_hrp);
+    }
+
+    btcOperator.convert.bech2bech = function (source_addr, target_version = coinjs.bech32.version, target_hrp = coinjs.bech32.hrp) {
+        let rawHex = util.decodeBech32(source_addr).hex;
+        if (!rawHex)
+            return null;
+        else
+            return util.encodeBech32(rawHex, target_version, target_hrp);
+    }
+
+    btcOperator.convert.bech2legacy = function (source_addr, target_version = coinjs.pub) {
+        let rawHex = util.decodeBech32(source_addr).hex;
+        if (!rawHex)
+            return null;
+        else
+            return util.encodeLegacy(rawHex, target_version);
+    }
+
+    btcOperator.convert.multisig2multisig = function (source_addr, target_version = coinjs.multisig) {
+        let rawHex = util.decodeLegacy(source_addr).hex;
+        if (!rawHex)
+            return null;
+        else
+            return util.encodeLegacy(rawHex, target_version);
+    }
+
+    btcOperator.convert.bech2multisig = function (source_addr, target_version = coinjs.multisig) {
+        let rawHex = util.decodeBech32(source_addr).hex;
+        if (!rawHex)
+            return null;
+        else {
+            rawHex = Crypto.util.bytesToHex(ripemd160(Crypto.util.hexToBytes(rawHex), { asBytes: true }));
+            return util.encodeLegacy(rawHex, target_version);
+        }
+    }
+
+    util.decodeLegacy = function (source) {
+        var decode = coinjs.base58decode(source);
+        var raw = decode.slice(0, decode.length - 4),
+            checksum = decode.slice(decode.length - 4);
+        var hash = Crypto.SHA256(Crypto.SHA256(raw, {
+            asBytes: true
+        }), {
+            asBytes: true
+        });
+        if (hash[0] != checksum[0] || hash[1] != checksum[1] || hash[2] != checksum[2] || hash[3] != checksum[3])
+            return false;
+        let version = raw.shift();
+        return {
+            version: version,
+            hex: Crypto.util.bytesToHex(raw)
+        }
+    }
+
+    util.encodeLegacy = function (hex, version) {
+        var bytes = Crypto.util.hexToBytes(hex);
+        bytes.unshift(version);
+        var hash = Crypto.SHA256(Crypto.SHA256(bytes, {
+            asBytes: true
+        }), {
+            asBytes: true
+        });
+        var checksum = hash.slice(0, 4);
+        return coinjs.base58encode(bytes.concat(checksum));
+    }
+
+    util.decodeBech32 = function (source) {
+        let decode = coinjs.bech32_decode(source);
+        if (!decode)
+            return false;
+        var raw = decode.data;
+        let version = raw.shift();
+        raw = coinjs.bech32_convert(raw, 5, 8, false);
+        return {
+            hrp: decode.hrp,
+            version: version,
+            hex: Crypto.util.bytesToHex(raw)
+        }
+    }
+
+    util.encodeBech32 = function (hex, version, hrp) {
+        var bytes = Crypto.util.hexToBytes(hex);
+        bytes = coinjs.bech32_convert(bytes, 8, 5, true);
+        bytes.unshift(version)
+        return coinjs.bech32_encode(hrp, bytes);
+    }
+
+    //BTC blockchain APIs
+
+    btcOperator.getBalance = addr => new Promise((resolve, reject) => {
+        fetch_api(`q/addressbalance/${addr}`)
+            .then(result => resolve(util.Sat_to_BTC(result)))
+            .catch(error => reject(error))
+    });
+
+    const BASE_TX_SIZE = 12,
+        BASE_INPUT_SIZE = 41,
+        LEGACY_INPUT_SIZE = 107,
+        BECH32_INPUT_SIZE = 27,
+        BECH32_MULTISIG_INPUT_SIZE = 35,
+        SEGWIT_INPUT_SIZE = 59,
+        MULTISIG_INPUT_SIZE_ES = 351,
+        BASE_OUTPUT_SIZE = 9,
+        LEGACY_OUTPUT_SIZE = 25,
+        BECH32_OUTPUT_SIZE = 23,
+        BECH32_MULTISIG_OUTPUT_SIZE = 34,
+        SEGWIT_OUTPUT_SIZE = 23;
+
+    function _redeemScript(addr, key) {
+        let decode = coinjs.addressDecode(addr);
+        switch (decode.type) {
+            case "standard":
+                return false;
+            case "multisig":
+                return key ? coinjs.segwitAddress(btcOperator.pubkey(key)).redeemscript : null;
+            case "bech32":
+                return decode.redeemscript;
+            default:
+                return null;
+        }
+    }
+
+    function _sizePerInput(addr, rs) {
+        switch (coinjs.addressDecode(addr).type) {
+            case "standard":
+                return BASE_INPUT_SIZE + LEGACY_INPUT_SIZE;
+            case "bech32":
+                return BASE_INPUT_SIZE + BECH32_INPUT_SIZE;
+            case "multisigBech32":
+                return BASE_INPUT_SIZE + BECH32_MULTISIG_INPUT_SIZE;
+            case "multisig":
+                switch (coinjs.script().decodeRedeemScript(rs).type) {
+                    case "segwit__":
+                        return BASE_INPUT_SIZE + SEGWIT_INPUT_SIZE;
+                    case "multisig__":
+                        return BASE_INPUT_SIZE + MULTISIG_INPUT_SIZE_ES;
+                    default:
+                        return null;
+                };
+            default:
+                return null;
+        }
+    }
+
+    function _sizePerOutput(addr) {
+        switch (coinjs.addressDecode(addr).type) {
+            case "standard":
+                return BASE_OUTPUT_SIZE + LEGACY_OUTPUT_SIZE;
+            case "bech32":
+                return BASE_OUTPUT_SIZE + BECH32_OUTPUT_SIZE;
+            case "multisigBech32":
+                return BASE_OUTPUT_SIZE + BECH32_MULTISIG_OUTPUT_SIZE;
+            case "multisig":
+                return BASE_OUTPUT_SIZE + SEGWIT_OUTPUT_SIZE;
+            default:
+                return null;
+        }
+    }
+
+    function validateTxParameters(parameters) {
+        let invalids = [];
+        //sender-ids
+        if (parameters.senders) {
+            if (!Array.isArray(parameters.senders))
+                parameters.senders = [parameters.senders];
+            parameters.senders.forEach(id => !validateAddress(id) ? invalids.push(id) : null);
+            if (invalids.length)
+                throw "Invalid senders:" + invalids;
+        }
+        if (parameters.privkeys) {
+            if (!Array.isArray(parameters.privkeys))
+                parameters.privkeys = [parameters.privkeys];
+            if (parameters.senders.length != parameters.privkeys.length)
+                throw "Array length for senders and privkeys should be equal";
+            parameters.senders.forEach((id, i) => {
+                let key = parameters.privkeys[i];
+                if (!verifyKey(id, key)) //verify private-key
+                    invalids.push(id);
+                if (key.length === 64) //convert Hex to WIF if needed
+                    parameters.privkeys[i] = coinjs.privkey2wif(key);
+            });
+            if (invalids.length)
+                throw "Invalid private key for address:" + invalids;
+        }
+        //receiver-ids (and change-id)
+        if (!Array.isArray(parameters.receivers))
+            parameters.receivers = [parameters.receivers];
+        parameters.receivers.forEach(id => !validateAddress(id) ? invalids.push(id) : null);
+        if (invalids.length)
+            throw "Invalid receivers:" + invalids;
+        if (parameters.change_address && !validateAddress(parameters.change_address))
+            throw "Invalid change_address:" + parameters.change_address;
+        //fee and amounts
+        if ((typeof parameters.fee !== "number" || parameters.fee <= 0) && parameters.fee !== null) //fee = null (auto calc)
+            throw "Invalid fee:" + parameters.fee;
+        if (!Array.isArray(parameters.amounts))
+            parameters.amounts = [parameters.amounts];
+        if (parameters.receivers.length != parameters.amounts.length)
+            throw "Array length for receivers and amounts should be equal";
+        parameters.amounts.forEach(a => typeof a !== "number" || a <= 0 ? invalids.push(a) : null);
+        if (invalids.length)
+            throw "Invalid amounts:" + invalids;
+        //return
+        return parameters;
+    }
+
+    function createTransaction(senders, redeemScripts, receivers, amounts, fee, change_address, fee_from_receiver) {
+        return new Promise((resolve, reject) => {
+            let total_amount = parseFloat(amounts.reduce((t, a) => t + a, 0).toFixed(8));
+            const tx = coinjs.transaction();
+            let output_size = addOutputs(tx, receivers, amounts, change_address);
+            addInputs(tx, senders, redeemScripts, total_amount, fee, output_size, fee_from_receiver).then(result => {
+                if (result.change_amount > 0 && result.change_amount > result.fee) //add change amount if any (ignore dust change)
+                    tx.outs[tx.outs.length - 1].value = util.BTC_to_Sat(result.change_amount); //values are in satoshi
+                if (fee_from_receiver) { //deduce fee from receivers if fee_from_receiver
+                    let fee_remaining = util.BTC_to_Sat(result.fee);
+                    for (let i = 0; i < tx.outs.length - 1 && fee_remaining > 0; i++) {
+                        if (fee_remaining < tx.outs[i].value) {
+                            tx.outs[i].value -= fee_remaining;
+                            fee_remaining = 0;
+                        } else {
+                            fee_remaining -= tx.outs[i].value;
+                            tx.outs[i].value = 0;
+                        }
+                    }
+                    if (fee_remaining > 0)
+                        return reject("Send amount is less than fee");
+
+                }
+                //remove all output with value less than DUST amount
+                let filtered_outputs = [], dust_value = 0;
+                tx.outs.forEach(o => o.value >= DUST_AMT ? filtered_outputs.push(o) : dust_value += o.value);
+                tx.outs = filtered_outputs;
+                //update result values
+                result.fee += util.Sat_to_BTC(dust_value);
+                result.output_size = output_size;
+                result.output_amount = total_amount - (fee_from_receiver ? result.fee : 0);
+                result.total_size = BASE_TX_SIZE + output_size + result.input_size;
+                result.transaction = tx;
+                resolve(result);
+            }).catch(error => reject(error))
+        })
+    }
+
+    function addInputs(tx, senders, redeemScripts, total_amount, fee, output_size, fee_from_receiver) {
+        return new Promise((resolve, reject) => {
+            if (fee !== null) {
+                addUTXOs(tx, senders, redeemScripts, fee_from_receiver ? total_amount : total_amount + fee, false).then(result => {
+                    result.fee = fee;
+                    resolve(result);
+                }).catch(error => reject(error))
+            } else {
+                get_fee_rate().then(fee_rate => {
+                    let net_fee = BASE_TX_SIZE * fee_rate;
+                    net_fee += (output_size * fee_rate);
+                    (fee_from_receiver ?
+                        addUTXOs(tx, senders, redeemScripts, total_amount, false) :
+                        addUTXOs(tx, senders, redeemScripts, total_amount + net_fee, fee_rate)
+                    ).then(result => {
+                        result.fee = parseFloat((net_fee + (result.input_size * fee_rate)).toFixed(8));
+                        result.fee_rate = fee_rate;
+                        resolve(result);
+                    }).catch(error => reject(error))
+                }).catch(error => reject(error))
+            }
+        })
+    }
+
+    function addUTXOs(tx, senders, redeemScripts, required_amount, fee_rate, rec_args = {}) {
+        return new Promise((resolve, reject) => {
+            required_amount = parseFloat(required_amount.toFixed(8));
+            if (typeof rec_args.n === "undefined") {
+                rec_args.n = 0;
+                rec_args.input_size = 0;
+                rec_args.input_amount = 0;
+            }
+            if (required_amount <= 0)
+                return resolve({
+                    input_size: rec_args.input_size,
+                    input_amount: rec_args.input_amount,
+                    change_amount: required_amount * -1 //required_amount will be -ve of change_amount
+                });
+            else if (rec_args.n >= senders.length)
+                return reject("Insufficient Balance");
+            let addr = senders[rec_args.n],
+                rs = redeemScripts[rec_args.n];
+            let addr_type = coinjs.addressDecode(addr).type;
+            let size_per_input = _sizePerInput(addr, rs);
+            fetch_api(`unspent?active=${addr}`).then(result => {
+                let utxos = result.unspent_outputs;
+                //console.debug("add-utxo", addr, rs, required_amount, utxos);
+                for (let i = 0; i < utxos.length && required_amount > 0; i++) {
+                    if (!utxos[i].confirmations) //ignore unconfirmed utxo
+                        continue;
+                    var script;
+                    if (!rs || !rs.length) //legacy script
+                        script = utxos[i].script;
+                    else if (((rs.match(/^00/) && rs.length == 44)) || (rs.length == 40 && rs.match(/^[a-f0-9]+$/gi)) || addr_type === 'multisigBech32') {
+                        //redeemScript for segwit/bech32 and multisig (bech32)
+                        let s = coinjs.script();
+                        s.writeBytes(Crypto.util.hexToBytes(rs));
+                        s.writeOp(0);
+                        s.writeBytes(coinjs.numToBytes(utxos[i].value.toFixed(0), 8));
+                        script = Crypto.util.bytesToHex(s.buffer);
+                    } else //redeemScript for multisig (segwit)
+                        script = rs;
+                    tx.addinput(utxos[i].tx_hash_big_endian, utxos[i].tx_output_n, script, 0xfffffffd /*sequence*/); //0xfffffffd for Replace-by-fee
+                    //update track values
+                    rec_args.input_size += size_per_input;
+                    rec_args.input_amount += util.Sat_to_BTC(utxos[i].value);
+                    required_amount -= util.Sat_to_BTC(utxos[i].value);
+                    if (fee_rate) //automatic fee calculation (dynamic)
+                        required_amount += size_per_input * fee_rate;
+                }
+                rec_args.n += 1;
+                addUTXOs(tx, senders, redeemScripts, required_amount, fee_rate, rec_args)
+                    .then(result => resolve(result))
+                    .catch(error => reject(error))
+            }).catch(error => reject(error))
+        })
+    }
+
+    function addOutputs(tx, receivers, amounts, change_address) {
+        let size = 0;
+        for (let i in receivers) {
+            tx.addoutput(receivers[i], amounts[i]);
+            size += _sizePerOutput(receivers[i]);
+        }
+        tx.addoutput(change_address, 0);
+        size += _sizePerOutput(change_address);
+        return size;
+    }
+
+    /*
+    function autoFeeCalc(tx) {
+        return new Promise((resolve, reject) => {
+            get_fee_rate().then(fee_rate => {
+                let tx_size = tx.size();
+                for (var i = 0; i < this.ins.length; i++)
+                    switch (tx.extractScriptKey(i).type) {
+                        case 'scriptpubkey':
+                            tx_size += SIGN_SIZE;
+                            break;
+                        case 'segwit':
+                        case 'multisig':
+                            tx_size += SIGN_SIZE * 0.25;
+                            break;
+                        default:
+                            console.warn('Unknown script-type');
+                            tx_size += SIGN_SIZE;
+                    }
+                resolve(tx_size * fee_rate);
+            }).catch(error => reject(error))
+        })
+    }
+
+    function editFee(tx, current_fee, target_fee, index = -1) {
+        //values are in satoshi
+        index = parseInt(index >= 0 ? index : tx.outs.length - index);
+        if (index < 0 || index >= tx.outs.length)
+            throw "Invalid index";
+        let edit_value = parseInt(current_fee - target_fee), //rip of any decimal places
+            current_value = tx.outs[index].value; //could be BigInterger
+        if (edit_value < 0 && edit_value > current_value)
+            throw "Insufficient value at vout";
+        tx.outs[index].value = current_value instanceof BigInteger ?
+            current_value.add(new BigInteger('' + edit_value)) : parseInt(current_value + edit_value);
+    }
+    */
+
+    function tx_fetch_for_editing(tx) {
+        return new Promise((resolve, reject) => {
+            if (typeof tx == 'string' && /^[0-9a-f]{64}$/i.test(tx)) { //tx is txid
+                getTx.hex(tx)
+                    .then(txhex => resolve(deserializeTx(txhex)))
+                    .catch(error => reject(error))
+            } else resolve(deserializeTx(tx));
+        })
+    }
+
+
+    btcOperator.editFee = 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 = [];
+                    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)) || addr_decode.type === 'multisigBech32') {
+                            //redeemScript for segwit/bech32 and multisig (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);
+                        } 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
+                    resolve(tx.serialize());
+                }).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;
+                broadcastTx(result.transaction.serialize())
+                    .then(txid => resolve(txid))
+                    .catch(error => reject(error));
+            }).catch(error => reject(error))
+        })
+    }
+
+    const createSignedTx = btcOperator.createSignedTx = function (senders, privkeys, receivers, amounts, fee = null, options = {}) {
+        return new Promise((resolve, reject) => {
+            try {
+                ({
+                    senders,
+                    privkeys,
+                    receivers,
+                    amounts
+                } = validateTxParameters({
+                    senders,
+                    privkeys,
+                    receivers,
+                    amounts,
+                    fee,
+                    change_address: options.change_address
+                }));
+            } catch (e) {
+                return reject(e)
+            }
+            let redeemScripts = [],
+                wif_keys = [];
+            for (let i in senders) {
+                let rs = _redeemScript(senders[i], privkeys[i]); //get redeem-script (segwit/bech32)
+                redeemScripts.push(rs);
+                rs === false ? wif_keys.unshift(privkeys[i]) : wif_keys.push(privkeys[i]); //sorting private-keys (wif)
+            }
+            if (redeemScripts.includes(null)) //TODO: segwit
+                return reject("Unable to get redeem-script");
+            //create transaction
+            createTransaction(senders, redeemScripts, receivers, amounts, fee, options.change_address || senders[0], options.fee_from_receiver).then(result => {
+                let tx = result.transaction;
+                console.debug("Unsigned:", tx.serialize());
+                new Set(wif_keys).forEach(key => tx.sign(key, 1 /*sighashtype*/)); //Sign the tx using private key WIF
+                console.debug("Signed:", tx.serialize());
+                resolve(result);
+            }).catch(error => reject(error));
+        })
+    }
+
+    btcOperator.createTx = function (senders, receivers, amounts, fee = null, options = {}) {
+        return new Promise((resolve, reject) => {
+            try {
+                ({
+                    senders,
+                    receivers,
+                    amounts
+                } = validateTxParameters({
+                    senders,
+                    receivers,
+                    amounts,
+                    fee,
+                    change_address: options.change_address
+                }));
+            } catch (e) {
+                return reject(e)
+            }
+            let redeemScripts = senders.map(id => _redeemScript(id));
+            if (redeemScripts.includes(null)) //TODO: segwit
+                return reject("Unable to get redeem-script");
+            //create transaction
+            createTransaction(senders, redeemScripts, receivers, amounts, fee, options.change_address || senders[0], options.fee_from_receiver).then(result => {
+                result.tx_hex = result.transaction.serialize();
+                delete result.transaction;
+                resolve(result);
+            }).catch(error => reject(error))
+        })
+    }
+
+    btcOperator.createMultiSigTx = function (sender, redeemScript, receivers, amounts, fee = null, options = {}) {
+        return new Promise((resolve, reject) => {
+            //validate tx parameters
+            let addr_type = validateAddress(sender);
+            if (!(["multisig", "multisigBech32"].includes(addr_type)))
+                return reject("Invalid sender (multisig):" + sender);
+            else {
+                let script = coinjs.script();
+                let decode = (addr_type == "multisig") ?
+                    script.decodeRedeemScript(redeemScript) :
+                    script.decodeRedeemScriptBech32(redeemScript);
+                if (!decode || decode.address !== sender)
+                    return reject("Invalid redeem-script");
+            }
+            try {
+                ({
+                    receivers,
+                    amounts
+                } = validateTxParameters({
+                    receivers,
+                    amounts,
+                    fee,
+                    change_address: options.change_address
+                }));
+            } catch (e) {
+                return reject(e)
+            }
+            //create transaction
+            createTransaction([sender], [redeemScript], receivers, amounts, fee, options.change_address || sender, options.fee_from_receiver).then(result => {
+                result.tx_hex = result.transaction.serialize();
+                delete result.transaction;
+                resolve(result);
+            }).catch(error => reject(error))
+
+        })
+    }
+
+    function deserializeTx(tx) {
+        if (typeof tx === 'string' || Array.isArray(tx)) {
+            try {
+                tx = coinjs.transaction().deserialize(tx);
+            } catch {
+                throw "Invalid transaction hex";
+            }
+        } else if (typeof tx !== 'object' || typeof tx.sign !== 'function')
+            throw "Invalid transaction object";
+        return tx;
+    }
+
+    btcOperator.signTx = function (tx, privkeys, sighashtype = 1) {
+        tx = deserializeTx(tx);
+        if (!Array.isArray(privkeys))
+            privkeys = [privkeys];
+        for (let i in privkeys)
+            if (privkeys[i].length === 64)
+                privkeys[i] = coinjs.privkey2wif(privkeys[i]);
+        new Set(privkeys).forEach(key => tx.sign(key, sighashtype)); //Sign the tx using private key WIF
+        return tx.serialize();
+    }
+
+    const checkSigned = btcOperator.checkSigned = function (tx, bool = true) {
+        tx = deserializeTx(tx);
+        let n = [];
+        for (let i in tx.ins) {
+            var s = tx.extractScriptKey(i);
+            if (s['type'] !== 'multisig' && s['type'] !== 'multisig_bech32')
+                n.push(s.signed == 'true' || (tx.witness[i] && tx.witness[i].length == 2))
+            else {
+                var rs = coinjs.script().decodeRedeemScript(s.script);  //will work for bech32 too, as only address is diff
+                let x = {
+                    s: s['signatures'],
+                    r: rs['signaturesRequired'],
+                    t: rs['pubkeys'].length
+                };
+                if (x.r > x.t)
+                    throw "signaturesRequired is more than publicKeys";
+                else if (x.s < x.r)
+                    n.push(x);
+                else
+                    n.push(true);
+            }
+        }
+        return bool ? !(n.filter(x => x !== true).length) : n;
+    }
+
+    btcOperator.checkIfSameTx = function (tx1, tx2) {
+        tx1 = deserializeTx(tx1);
+        tx2 = deserializeTx(tx2);
+        //compare input and output length
+        if (tx1.ins.length !== tx2.ins.length || tx1.outs.length !== tx2.outs.length)
+            return false;
+        //compare inputs
+        for (let i = 0; i < tx1.ins.length; i++)
+            if (tx1.ins[i].outpoint.hash !== tx2.ins[i].outpoint.hash || tx1.ins[i].outpoint.index !== tx2.ins[i].outpoint.index)
+                return false;
+        //compare outputs
+        for (let i = 0; i < tx1.outs.length; i++)
+            if (tx1.outs[i].value !== tx2.outs[i].value || Crypto.util.bytesToHex(tx1.outs[i].script.buffer) !== Crypto.util.bytesToHex(tx2.outs[i].script.buffer))
+                return false;
+        return true;
+    }
+
+    const getTxOutput = (txid, i) => new Promise((resolve, reject) => {
+        fetch_api(`rawtx/${txid}`)
+            .then(result => resolve(result.out[i]))
+            .catch(error => reject(error))
+    });
+
+    const parseTransaction = btcOperator.parseTransaction = function (tx) {
+        return new Promise((resolve, reject) => {
+            tx = deserializeTx(tx);
+            let result = {};
+            let promises = [];
+            //Parse Inputs
+            for (let i = 0; i < tx.ins.length; i++)
+                promises.push(getTxOutput(tx.ins[i].outpoint.hash, tx.ins[i].outpoint.index));
+            Promise.all(promises).then(inputs => {
+                result.inputs = inputs.map(inp => Object({
+                    address: inp.addr,
+                    value: util.Sat_to_BTC(inp.value)
+                }));
+                let signed = checkSigned(tx, false);
+                result.inputs.forEach((inp, i) => inp.signed = signed[i]);
+                //Parse Outputs
+                result.outputs = tx.outs.map(out => {
+                    var address;
+                    switch (out.script.chunks[0]) {
+                        case 0: //bech32, multisig-bech32
+                            address = util.encodeBech32(Crypto.util.bytesToHex(out.script.chunks[1]), coinjs.bech32.version, coinjs.bech32.hrp);
+                            break;
+                        case 169: //segwit, multisig-segwit
+                            address = util.encodeLegacy(Crypto.util.bytesToHex(out.script.chunks[1]), coinjs.multisig);
+                            break;
+                        case 118: //legacy
+                            address = util.encodeLegacy(Crypto.util.bytesToHex(out.script.chunks[2]), coinjs.pub);
+                    }
+                    return {
+                        address,
+                        value: util.Sat_to_BTC(out.value)
+                    }
+                });
+                //Parse Totals
+                result.total_input = parseFloat(result.inputs.reduce((a, inp) => a += inp.value, 0).toFixed(8));
+                result.total_output = parseFloat(result.outputs.reduce((a, out) => a += out.value, 0).toFixed(8));
+                result.fee = parseFloat((result.total_input - result.total_output).toFixed(8));
+                resolve(result);
+            }).catch(error => reject(error))
+        })
+    }
+
+    btcOperator.transactionID = function (tx) {
+        tx = deserializeTx(tx);
+        let clone = coinjs.clone(tx);
+        clone.witness = null;
+        let raw_bytes = Crypto.util.hexToBytes(clone.serialize());
+        let txid = Crypto.SHA256(Crypto.SHA256(raw_bytes, { asBytes: true }), { asBytes: true }).reverse();
+        return Crypto.util.bytesToHex(txid);
+    }
+
+    const getLatestBlock = btcOperator.getLatestBlock = () => new Promise((resolve, reject) => {
+        fetch_api(`q/getblockcount`)
+            .then(result => resolve(result))
+            .catch(error => reject(error))
+    })
+
+    const getTx = btcOperator.getTx = txid => new Promise((resolve, reject) => {
+        fetch_api(`rawtx/${txid}`).then(result => {
+            getLatestBlock().then(latest_block => resolve({
+                block: result.block_height,
+                txid: result.hash,
+                time: result.time * 1000,
+                confirmations: result.block_height === null ? 0 : latest_block - result.block_height, //calculate confirmations using latest block number as api doesnt relay it
+                size: result.size,
+                fee: util.Sat_to_BTC(result.fee),
+                inputs: result.inputs.map(i => Object({ address: i.prev_out.addr, value: util.Sat_to_BTC(i.prev_out.value) })),
+                total_input_value: util.Sat_to_BTC(result.inputs.reduce((a, i) => a + i.prev_out.value, 0)),
+                outputs: result.out.map(o => Object({ address: o.addr, value: util.Sat_to_BTC(o.value) })),
+                total_output_value: util.Sat_to_BTC(result.out.reduce((a, o) => a += o.value, 0)),
+            }))
+        }).catch(error => reject(error))
+    });
+
+    getTx.hex = txid => new Promise((resolve, reject) => {
+        fetch_api(`rawtx/${txid}?format=hex`, false)
+            .then(result => resolve(result))
+            .catch(error => reject(error))
+    })
+
+    btcOperator.getAddressData = address => new Promise((resolve, reject) => {
+        fetch_api(`rawaddr/${address}`).then(data => {
+            let details = {};
+            details.balance = util.Sat_to_BTC(data.final_balance);
+            details.address = data.address;
+            details.txs = data.txs.map(tx => {
+                let d = {
+                    txid: tx.hash,
+                    time: tx.time * 1000, //s to ms
+                    block: tx.block_height,
+                }
+                //sender list
+                d.tx_senders = {};
+                tx.inputs.forEach(i => {
+                    if (i.prev_out.addr in d.tx_senders)
+                        d.tx_senders[i.prev_out.addr] += i.prev_out.value;
+                    else d.tx_senders[i.prev_out.addr] = i.prev_out.value;
+                });
+                d.tx_input_value = 0;
+                for (let s in d.tx_senders) {
+                    let val = d.tx_senders[s];
+                    d.tx_senders[s] = util.Sat_to_BTC(val);
+                    d.tx_input_value += val;
+                }
+                d.tx_input_value = util.Sat_to_BTC(d.tx_input_value);
+                //receiver list
+                d.tx_receivers = {};
+                tx.out.forEach(o => {
+                    if (o.addr in d.tx_receivers)
+                        d.tx_receivers[o.addr] += o.value;
+                    else d.tx_receivers[o.addr] = o.value;
+                });
+                d.tx_output_value = 0;
+                for (let r in d.tx_receivers) {
+                    let val = d.tx_receivers[r];
+                    d.tx_receivers[r] = util.Sat_to_BTC(val);
+                    d.tx_output_value += val;
+                }
+                d.tx_output_value = util.Sat_to_BTC(d.tx_output_value);
+                d.tx_fee = util.Sat_to_BTC(tx.fee);
+                //tx type
+                if (tx.result > 0) { //net > 0, balance inc => type=in
+                    d.type = "in";
+                    d.amount = util.Sat_to_BTC(tx.result);
+                    d.sender = Object.keys(d.tx_senders).filter(s => s !== address);
+                } else if (Object.keys(d.tx_receivers).some(r => r !== address)) { //net < 0, balance dec & receiver present => type=out
+                    d.type = "out";
+                    d.amount = util.Sat_to_BTC(tx.result * -1);
+                    d.receiver = Object.keys(d.tx_receivers).filter(r => r !== address);
+                    d.fee = d.tx_fee;
+                } else { //net < 0 (fee) & no other id in receiver list => type=self
+                    d.type = "self";
+                    d.amount = d.tx_receivers[address];
+                    d.address = address
+                }
+                return d;
+            })
+            resolve(details);
+        }).catch(error => reject(error))
+    });
+
+    btcOperator.getBlock = block => new Promise((resolve, reject) => {
+        fetch_api(`rawblock/${block}`).then(result => resolve({
+            height: result.height,
+            hash: result.hash,
+            merkle_root: result.mrkl_root,
+            prev_block: result.prev_block,
+            next_block: result.next_block[0],
+            size: result.size,
+            time: result.time * 1000, //s to ms
+            txs: result.tx.map(t => Object({
+                fee: t.fee,
+                size: t.size,
+                inputs: t.inputs.map(i => Object({ address: i.prev_out.addr, value: util.Sat_to_BTC(i.prev_out.value) })),
+                total_input_value: util.Sat_to_BTC(t.inputs.reduce((a, i) => a + i.prev_out.value, 0)),
+                outputs: t.out.map(o => Object({ address: o.addr, value: util.Sat_to_BTC(o.value) })),
+                total_output_value: util.Sat_to_BTC(t.out.reduce((a, o) => a += o.value, 0)),
+            }))
+
+        })).catch(error => reject(error))
+    });
+
+})('object' === typeof module ? module.exports : window.btcOperator = {});

scripts/compactIDB.js

@@ -0,0 +1,257 @@
+(function (EXPORTS) { //compactIDB v2.1.2
+    /* Compact IndexedDB operations */
+    'use strict';
+    const compactIDB = EXPORTS;
+
+    var defaultDB;
+
+    const indexedDB = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
+    const IDBTransaction = window.IDBTransaction || window.webkitIDBTransaction || window.msIDBTransaction;
+    const IDBKeyRange = window.IDBKeyRange || window.webkitIDBKeyRange || window.msIDBKeyRange;
+
+    if (!indexedDB) {
+        console.error("Your browser doesn't support a stable version of IndexedDB.");
+        return;
+    }
+
+    compactIDB.setDefaultDB = dbName => defaultDB = dbName;
+
+    Object.defineProperty(compactIDB, 'default', {
+        get: () => defaultDB,
+        set: dbName => defaultDB = dbName
+    });
+
+    function getDBversion(dbName = defaultDB) {
+        return new Promise((resolve, reject) => {
+            openDB(dbName).then(db => {
+                resolve(db.version)
+                db.close()
+            }).catch(error => reject(error))
+        })
+    }
+
+    function upgradeDB(dbName, createList = null, deleteList = null) {
+        return new Promise((resolve, reject) => {
+            getDBversion(dbName).then(version => {
+                var idb = indexedDB.open(dbName, version + 1);
+                idb.onerror = (event) => reject("Error in opening IndexedDB");
+                idb.onupgradeneeded = (event) => {
+                    let db = event.target.result;
+                    if (createList instanceof Object) {
+                        if (Array.isArray(createList)) {
+                            let tmp = {}
+                            createList.forEach(o => tmp[o] = {})
+                            createList = tmp
+                        }
+                        for (let o in createList) {
+                            let obs = db.createObjectStore(o, createList[o].options || {});
+                            if (createList[o].indexes instanceof Object)
+                                for (let i in createList[o].indexes)
+                                    obs.createIndex(i, i, createList[o].indexes || {});
+                        }
+                    }
+                    if (Array.isArray(deleteList))
+                        deleteList.forEach(o => db.deleteObjectStore(o));
+                    resolve('Database upgraded')
+                }
+                idb.onsuccess = (event) => event.target.result.close();
+            }).catch(error => reject(error))
+        })
+    }
+
+    compactIDB.initDB = function (dbName, objectStores = {}) {
+        return new Promise((resolve, reject) => {
+            if (!(objectStores instanceof Object))
+                return reject('ObjectStores must be an object or array')
+            defaultDB = defaultDB || dbName;
+            var idb = indexedDB.open(dbName);
+            idb.onerror = (event) => reject("Error in opening IndexedDB");
+            idb.onsuccess = (event) => {
+                var db = event.target.result;
+                let cList = Object.values(db.objectStoreNames);
+                var obs = {},
+                    a_obs = {},
+                    d_obs = [];
+                if (!Array.isArray(objectStores))
+                    var obs = objectStores
+                else
+                    objectStores.forEach(o => obs[o] = {})
+                let nList = Object.keys(obs)
+                for (let o of nList)
+                    if (!cList.includes(o))
+                        a_obs[o] = obs[o]
+                for (let o of cList)
+                    if (!nList.includes(o))
+                        d_obs.push(o)
+                if (!Object.keys(a_obs).length && !d_obs.length)
+                    resolve("Initiated IndexedDB");
+                else
+                    upgradeDB(dbName, a_obs, d_obs)
+                        .then(result => resolve(result))
+                        .catch(error => reject(error))
+                db.close();
+            }
+        });
+    }
+
+    const openDB = compactIDB.openDB = function (dbName = defaultDB) {
+        return new Promise((resolve, reject) => {
+            var idb = indexedDB.open(dbName);
+            idb.onerror = (event) => reject("Error in opening IndexedDB");
+            idb.onupgradeneeded = (event) => {
+                event.target.result.close();
+                deleteDB(dbName).then(_ => null).catch(_ => null).finally(_ => reject("Datebase not found"))
+            }
+            idb.onsuccess = (event) => resolve(event.target.result);
+        });
+    }
+
+    const deleteDB = compactIDB.deleteDB = function (dbName = defaultDB) {
+        return new Promise((resolve, reject) => {
+            var deleteReq = indexedDB.deleteDatabase(dbName);;
+            deleteReq.onerror = (event) => reject("Error deleting database!");
+            deleteReq.onsuccess = (event) => resolve("Database deleted successfully");
+        });
+    }
+
+    compactIDB.writeData = function (obsName, data, key = false, dbName = defaultDB) {
+        return new Promise((resolve, reject) => {
+            openDB(dbName).then(db => {
+                var obs = db.transaction(obsName, "readwrite").objectStore(obsName);
+                let writeReq = (key ? obs.put(data, key) : obs.put(data));
+                writeReq.onsuccess = (evt) => resolve(`Write data Successful`);
+                writeReq.onerror = (evt) => reject(
+                    `Write data unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`
+                );
+                db.close();
+            }).catch(error => reject(error));
+        });
+    }
+
+    compactIDB.addData = function (obsName, data, key = false, dbName = defaultDB) {
+        return new Promise((resolve, reject) => {
+            openDB(dbName).then(db => {
+                var obs = db.transaction(obsName, "readwrite").objectStore(obsName);
+                let addReq = (key ? obs.add(data, key) : obs.add(data));
+                addReq.onsuccess = (evt) => resolve(`Add data successful`);
+                addReq.onerror = (evt) => reject(
+                    `Add data unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`
+                );
+                db.close();
+            }).catch(error => reject(error));
+        });
+    }
+
+    compactIDB.removeData = function (obsName, key, dbName = defaultDB) {
+        return new Promise((resolve, reject) => {
+            openDB(dbName).then(db => {
+                var obs = db.transaction(obsName, "readwrite").objectStore(obsName);
+                let delReq = obs.delete(key);
+                delReq.onsuccess = (evt) => resolve(`Removed Data ${key}`);
+                delReq.onerror = (evt) => reject(
+                    `Remove data unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`
+                );
+                db.close();
+            }).catch(error => reject(error));
+        });
+    }
+
+    compactIDB.clearData = function (obsName, dbName = defaultDB) {
+        return new Promise((resolve, reject) => {
+            openDB(dbName).then(db => {
+                var obs = db.transaction(obsName, "readwrite").objectStore(obsName);
+                let clearReq = obs.clear();
+                clearReq.onsuccess = (evt) => resolve(`Clear data Successful`);
+                clearReq.onerror = (evt) => reject(`Clear data Unsuccessful`);
+                db.close();
+            }).catch(error => reject(error));
+        });
+    }
+
+    compactIDB.readData = function (obsName, key, dbName = defaultDB) {
+        return new Promise((resolve, reject) => {
+            openDB(dbName).then(db => {
+                var obs = db.transaction(obsName, "readonly").objectStore(obsName);
+                let getReq = obs.get(key);
+                getReq.onsuccess = (evt) => resolve(evt.target.result);
+                getReq.onerror = (evt) => reject(
+                    `Read data unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`
+                );
+                db.close();
+            }).catch(error => reject(error));
+        });
+    }
+
+    compactIDB.readAllData = function (obsName, dbName = defaultDB) {
+        return new Promise((resolve, reject) => {
+            openDB(dbName).then(db => {
+                var obs = db.transaction(obsName, "readonly").objectStore(obsName);
+                var tmpResult = {}
+                let curReq = obs.openCursor();
+                curReq.onsuccess = (evt) => {
+                    var cursor = evt.target.result;
+                    if (cursor) {
+                        tmpResult[cursor.primaryKey] = cursor.value;
+                        cursor.continue();
+                    } else
+                        resolve(tmpResult);
+                }
+                curReq.onerror = (evt) => reject(
+                    `Read-All data unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`
+                );
+                db.close();
+            }).catch(error => reject(error));
+        });
+    }
+
+    /* compactIDB.searchData = function (obsName, options = {}, dbName = defaultDB) {
+        
+        return new Promise((resolve, reject) => {
+            openDB(dbName).then(db => {
+                var obs = db.transaction(obsName, "readonly").objectStore(obsName);
+                var filteredResult = {}
+                let keyRange;
+                if(options.lowerKey!==null && options.upperKey!==null)
+                    keyRange = IDBKeyRange.bound(options.lowerKey, options.upperKey);
+                else if(options.lowerKey!==null)
+                    keyRange = IDBKeyRange.lowerBound(options.lowerKey);
+                else if (options.upperKey!==null)
+                    keyRange = IDBKeyRange.upperBound(options.upperBound);
+                else if (options.atKey)
+                let curReq = obs.openCursor(keyRange, )
+            }).catch(error => reject(error))
+        })
+    }*/
+
+    compactIDB.searchData = function (obsName, options = {}, dbName = defaultDB) {
+        options.lowerKey = options.atKey || options.lowerKey || 0
+        options.upperKey = options.atKey || options.upperKey || false
+        options.patternEval = options.patternEval || ((k, v) => true);
+        options.limit = options.limit || false;
+        options.reverse = options.reverse || false;
+        options.lastOnly = options.lastOnly || false
+        return new Promise((resolve, reject) => {
+            openDB(dbName).then(db => {
+                var obs = db.transaction(obsName, "readonly").objectStore(obsName);
+                var filteredResult = {}
+                let curReq = obs.openCursor(
+                    options.upperKey ? IDBKeyRange.bound(options.lowerKey, options.upperKey) : IDBKeyRange.lowerBound(options.lowerKey),
+                    options.lastOnly || options.reverse ? "prev" : "next");
+                curReq.onsuccess = (evt) => {
+                    var cursor = evt.target.result;
+                    if (!cursor || (options.limit && options.limit <= Object.keys(filteredResult).length))
+                        return resolve(filteredResult); //reached end of key list or limit reached
+                    else if (options.patternEval(cursor.primaryKey, cursor.value)) {
+                        filteredResult[cursor.primaryKey] = cursor.value;
+                        options.lastOnly ? resolve(filteredResult) : cursor.continue();
+                    } else
+                        cursor.continue();
+                }
+                curReq.onerror = (evt) => reject(`Search unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`);
+                db.close();
+            }).catch(error => reject(error));
+        });
+    }
+
+
+})(window.compactIDB = {});

scripts/floCrypto.js

@@ -0,0 +1,530 @@
+(function (EXPORTS) { //floCrypto v2.3.6a
+    /* FLO Crypto Operators */
+    'use strict';
+    const floCrypto = EXPORTS;
+
+    const p = BigInteger("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F", 16);
+    const ecparams = EllipticCurve.getSECCurveByName("secp256k1");
+    const ascii_alternatives = `‘ '\n’ '\n“ "\n” "\n– --\n— ---\n≥ >=\n≤ <=\n≠ !=\n× *\n÷ /\n← <-\n→ ->\n↔ <->\n⇒ =>\n⇐ <=\n⇔ <=>`;
+    const exponent1 = () => p.add(BigInteger.ONE).divide(BigInteger("4"));
+    coinjs.compressed = true; //defaulting coinjs compressed to true;
+
+    function calculateY(x) {
+        let exp = exponent1();
+        // x is x value of public key in BigInteger format without 02 or 03 or 04 prefix
+        return x.modPow(BigInteger("3"), p).add(BigInteger("7")).mod(p).modPow(exp, p)
+    }
+
+    function getUncompressedPublicKey(compressedPublicKey) {
+        // Fetch x from compressedPublicKey
+        let pubKeyBytes = Crypto.util.hexToBytes(compressedPublicKey);
+        const prefix = pubKeyBytes.shift() // remove prefix
+        let prefix_modulus = prefix % 2;
+        pubKeyBytes.unshift(0) // add prefix 0
+        let x = new BigInteger(pubKeyBytes)
+        let xDecimalValue = x.toString()
+        // Fetch y
+        let y = calculateY(x);
+        let yDecimalValue = y.toString();
+        // verify y value
+        let resultBigInt = y.mod(BigInteger("2"));
+        let check = resultBigInt.toString() % 2;
+        if (prefix_modulus !== check)
+            yDecimalValue = y.negate().mod(p).toString();
+        return {
+            x: xDecimalValue,
+            y: yDecimalValue
+        };
+    }
+
+    function getSenderPublicKeyString() {
+        let privateKey = ellipticCurveEncryption.senderRandom();
+        var senderPublicKeyString = ellipticCurveEncryption.senderPublicString(privateKey);
+        return {
+            privateKey: privateKey,
+            senderPublicKeyString: senderPublicKeyString
+        }
+    }
+
+    function deriveSharedKeySender(receiverPublicKeyHex, senderPrivateKey) {
+        let receiverPublicKeyString = getUncompressedPublicKey(receiverPublicKeyHex);
+        var senderDerivedKey = ellipticCurveEncryption.senderSharedKeyDerivation(
+            receiverPublicKeyString.x, receiverPublicKeyString.y, senderPrivateKey);
+        return senderDerivedKey;
+    }
+
+    function deriveSharedKeyReceiver(senderPublicKeyString, receiverPrivateKey) {
+        return ellipticCurveEncryption.receiverSharedKeyDerivation(
+            senderPublicKeyString.XValuePublicString, senderPublicKeyString.YValuePublicString, receiverPrivateKey);
+    }
+
+    function getReceiverPublicKeyString(privateKey) {
+        return ellipticCurveEncryption.receiverPublicString(privateKey);
+    }
+
+    function wifToDecimal(pk_wif, isPubKeyCompressed = false) {
+        let pk = Bitcoin.Base58.decode(pk_wif)
+        pk.shift()
+        pk.splice(-4, 4)
+        //If the private key corresponded to a compressed public key, also drop the last byte (it should be 0x01).
+        if (isPubKeyCompressed == true) pk.pop()
+        pk.unshift(0)
+        let privateKeyDecimal = BigInteger(pk).toString()
+        let privateKeyHex = Crypto.util.bytesToHex(pk)
+        return {
+            privateKeyDecimal: privateKeyDecimal,
+            privateKeyHex: privateKeyHex
+        }
+    }
+
+    //generate a random Interger within range
+    floCrypto.randInt = function (min, max) {
+        min = Math.ceil(min);
+        max = Math.floor(max);
+        return Math.floor(securedMathRandom() * (max - min + 1)) + min;
+    }
+
+    //generate a random String within length (options : alphaNumeric chars only)
+    floCrypto.randString = function (length, alphaNumeric = true) {
+        var result = '';
+        var characters = alphaNumeric ? 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789' :
+            'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_+-./*?@#&$<>=[]{}():';
+        for (var i = 0; i < length; i++)
+            result += characters.charAt(Math.floor(securedMathRandom() * characters.length));
+        return result;
+    }
+
+    //Encrypt Data using public-key
+    floCrypto.encryptData = function (data, receiverPublicKeyHex) {
+        var senderECKeyData = getSenderPublicKeyString();
+        var senderDerivedKey = deriveSharedKeySender(receiverPublicKeyHex, senderECKeyData.privateKey);
+        let senderKey = senderDerivedKey.XValue + senderDerivedKey.YValue;
+        let secret = Crypto.AES.encrypt(data, senderKey);
+        return {
+            secret: secret,
+            senderPublicKeyString: senderECKeyData.senderPublicKeyString
+        };
+    }
+
+    //Decrypt Data using private-key
+    floCrypto.decryptData = function (data, privateKeyHex) {
+        var receiverECKeyData = {};
+        if (typeof privateKeyHex !== "string") throw new Error("No private key found.");
+        let privateKey = wifToDecimal(privateKeyHex, true);
+        if (typeof privateKey.privateKeyDecimal !== "string") throw new Error("Failed to detremine your private key.");
+        receiverECKeyData.privateKey = privateKey.privateKeyDecimal;
+        var receiverDerivedKey = deriveSharedKeyReceiver(data.senderPublicKeyString, receiverECKeyData.privateKey);
+        let receiverKey = receiverDerivedKey.XValue + receiverDerivedKey.YValue;
+        let decryptMsg = Crypto.AES.decrypt(data.secret, receiverKey);
+        return decryptMsg;
+    }
+
+    //Sign data using private-key
+    floCrypto.signData = function (data, privateKeyHex) {
+        var key = new Bitcoin.ECKey(privateKeyHex);
+        var messageHash = Crypto.SHA256(data);
+        var messageSign = Bitcoin.ECDSA.sign(messageHash, key.priv);
+        var sighex = Crypto.util.bytesToHex(messageSign);
+        return sighex;
+    }
+
+    //Verify signatue of the data using public-key
+    floCrypto.verifySign = function (data, signatureHex, publicKeyHex) {
+        var msgHash = Crypto.SHA256(data);
+        var sigBytes = Crypto.util.hexToBytes(signatureHex);
+        var publicKeyPoint = ecparams.getCurve().decodePointHex(publicKeyHex);
+        var verify = Bitcoin.ECDSA.verify(msgHash, sigBytes, publicKeyPoint);
+        return verify;
+    }
+
+    //Generates a new flo ID and returns private-key, public-key and floID
+    const generateNewID = floCrypto.generateNewID = function () {
+        var key = new Bitcoin.ECKey(false);
+        key.setCompressed(true);
+        return {
+            floID: key.getBitcoinAddress(),
+            pubKey: key.getPubKeyHex(),
+            privKey: key.getBitcoinWalletImportFormat()
+        }
+    }
+
+    Object.defineProperties(floCrypto, {
+        newID: {
+            get: () => generateNewID()
+        },
+        hashID: {
+            value: (str) => {
+                let bytes = ripemd160(Crypto.SHA256(str, { asBytes: true }), { asBytes: true });
+                bytes.unshift(bitjs.pub);
+                var hash = Crypto.SHA256(Crypto.SHA256(bytes, {
+                    asBytes: true
+                }), {
+                    asBytes: true
+                });
+                var checksum = hash.slice(0, 4);
+                return bitjs.Base58.encode(bytes.concat(checksum));
+            }
+        },
+        tmpID: {
+            get: () => {
+                let bytes = Crypto.util.randomBytes(20);
+                bytes.unshift(bitjs.pub);
+                var hash = Crypto.SHA256(Crypto.SHA256(bytes, {
+                    asBytes: true
+                }), {
+                    asBytes: true
+                });
+                var checksum = hash.slice(0, 4);
+                return bitjs.Base58.encode(bytes.concat(checksum));
+            }
+        }
+    });
+
+    //Returns public-key from private-key
+    floCrypto.getPubKeyHex = function (privateKeyHex) {
+        if (!privateKeyHex)
+            return null;
+        var key = new Bitcoin.ECKey(privateKeyHex);
+        if (key.priv == null)
+            return null;
+        key.setCompressed(true);
+        return key.getPubKeyHex();
+    }
+
+    //Returns flo-ID from public-key or private-key
+    floCrypto.getFloID = function (keyHex) {
+        if (!keyHex)
+            return null;
+        try {
+            var key = new Bitcoin.ECKey(keyHex);
+            if (key.priv == null)
+                key.setPub(keyHex);
+            return key.getBitcoinAddress();
+        } catch {
+            return null;
+        }
+    }
+
+    floCrypto.getAddress = function (privateKeyHex, strict = false) {
+        if (!privateKeyHex)
+            return;
+        var key = new Bitcoin.ECKey(privateKeyHex);
+        if (key.priv == null)
+            return null;
+        key.setCompressed(true);
+        let pubKey = key.getPubKeyHex(),
+            version = bitjs.Base58.decode(privateKeyHex)[0];
+        switch (version) {
+            case coinjs.priv: //BTC
+                return coinjs.bech32Address(pubKey).address;
+            case bitjs.priv: //FLO
+                return bitjs.pubkey2address(pubKey);
+            default:
+                return strict ? false : bitjs.pubkey2address(pubKey); //default to FLO address (if strict=false)
+        }
+    }
+
+    //Verify the private-key for the given public-key or flo-ID
+    floCrypto.verifyPrivKey = function (privateKeyHex, pubKey_floID, isfloID = true) {
+        if (!privateKeyHex || !pubKey_floID)
+            return false;
+        try {
+            var key = new Bitcoin.ECKey(privateKeyHex);
+            if (key.priv == null)
+                return false;
+            key.setCompressed(true);
+            if (isfloID && pubKey_floID == key.getBitcoinAddress())
+                return true;
+            else if (!isfloID && pubKey_floID.toUpperCase() == key.getPubKeyHex().toUpperCase())
+                return true;
+            else
+                return false;
+        } catch {
+            return null;
+        }
+    }
+
+    floCrypto.getMultisigAddress = function (publicKeyList, requiredSignatures) {
+        if (!Array.isArray(publicKeyList) || !publicKeyList.length)
+            return null;
+        if (!Number.isInteger(requiredSignatures) || requiredSignatures < 1 || requiredSignatures > publicKeyList.length)
+            return null;
+        try {
+            var multisig = bitjs.pubkeys2multisig(publicKeyList, requiredSignatures);
+            return multisig;
+        } catch {
+            return null;
+        }
+    }
+
+    floCrypto.decodeRedeemScript = function (redeemScript) {
+        try {
+            var decoded = bitjs.transaction().decodeRedeemScript(redeemScript);
+            return decoded;
+        } catch {
+            return null;
+        }
+    }
+
+    //Check if the given flo-id is valid or not
+    floCrypto.validateFloID = function (floID, regularOnly = false) {
+        if (!floID)
+            return false;
+        try {
+            let addr = new Bitcoin.Address(floID);
+            if (regularOnly && addr.version != Bitcoin.Address.standardVersion)
+                return false;
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    //Check if the given address (any blockchain) is valid or not
+    floCrypto.validateAddr = function (address, std = true, bech = true) {
+        let raw = decodeAddress(address);
+        if (!raw)
+            return false;
+        if (typeof raw.version !== 'undefined') { //legacy or segwit
+            if (std == false)
+                return false;
+            else if (std === true || (!Array.isArray(std) && std === raw.version) || (Array.isArray(std) && std.includes(raw.version)))
+                return true;
+            else
+                return false;
+        } else if (typeof raw.bech_version !== 'undefined') { //bech32
+            if (bech === false)
+                return false;
+            else if (bech === true || (!Array.isArray(bech) && bech === raw.bech_version) || (Array.isArray(bech) && bech.includes(raw.bech_version)))
+                return true;
+            else
+                return false;
+        } else //unknown
+            return false;
+    }
+
+    //Check the public-key (or redeem-script) for the address (any blockchain)
+    floCrypto.verifyPubKey = function (pubKeyHex, address) {
+        let raw = decodeAddress(address);
+        if (!raw)
+            return;
+        let pub_hash = Crypto.util.bytesToHex(ripemd160(Crypto.SHA256(Crypto.util.hexToBytes(pubKeyHex), { asBytes: true })));
+        if (typeof raw.bech_version !== 'undefined' && raw.bytes.length == 32) //bech32-multisig
+            raw.hex = Crypto.util.bytesToHex(ripemd160(raw.bytes, { asBytes: true }));
+        return pub_hash === raw.hex;
+    }
+
+    //Convert the given address (any blockchain) to equivalent floID
+    floCrypto.toFloID = function (address, options = null) {
+        if (!address)
+            return;
+        let raw = decodeAddress(address);
+        if (!raw)
+            return;
+        else if (options) { //if (optional) version check is passed
+            if (typeof raw.version !== 'undefined' && (!options.std || !options.std.includes(raw.version)))
+                return;
+            if (typeof raw.bech_version !== 'undefined' && (!options.bech || !options.bech.includes(raw.bech_version)))
+                return;
+        }
+        raw.bytes.unshift(bitjs.pub);
+        let hash = Crypto.SHA256(Crypto.SHA256(raw.bytes, {
+            asBytes: true
+        }), {
+            asBytes: true
+        });
+        return bitjs.Base58.encode(raw.bytes.concat(hash.slice(0, 4)));
+    }
+
+    //Convert raw address bytes to floID
+    floCrypto.rawToFloID = function (raw_bytes) {
+        if (typeof raw_bytes === 'string')
+            raw_bytes = Crypto.util.hexToBytes(raw_bytes);
+        if (raw_bytes.length != 20)
+            return null;
+        raw_bytes.unshift(bitjs.pub);
+        let hash = Crypto.SHA256(Crypto.SHA256(raw_bytes, {
+            asBytes: true
+        }), {
+            asBytes: true
+        });
+        return bitjs.Base58.encode(raw_bytes.concat(hash.slice(0, 4)));
+    }
+
+    //Convert the given multisig address (any blockchain) to equivalent multisig floID
+    floCrypto.toMultisigFloID = function (address, options = null) {
+        if (!address)
+            return;
+        let raw = decodeAddress(address);
+        if (!raw)
+            return;
+        else if (options) { //if (optional) version check is passed
+            if (typeof raw.version !== 'undefined' && (!options.std || !options.std.includes(raw.version)))
+                return;
+            if (typeof raw.bech_version !== 'undefined' && (!options.bech || !options.bech.includes(raw.bech_version)))
+                return;
+        }
+        if (typeof raw.bech_version !== 'undefined') {
+            if (raw.bytes.length != 32) return; //multisig bech address have 32 bytes
+            //multisig-bech:hash=SHA256 whereas multisig:hash=r160(SHA265), thus ripemd160 the bytes from multisig-bech
+            raw.bytes = ripemd160(raw.bytes, {
+                asBytes: true
+            });
+        }
+        raw.bytes.unshift(bitjs.multisig);
+        let hash = Crypto.SHA256(Crypto.SHA256(raw.bytes, {
+            asBytes: true
+        }), {
+            asBytes: true
+        });
+        return bitjs.Base58.encode(raw.bytes.concat(hash.slice(0, 4)));
+    }
+
+    //Checks if the given addresses (any blockchain) are same (w.r.t keys)
+    floCrypto.isSameAddr = function (addr1, addr2) {
+        if (!addr1 || !addr2)
+            return;
+        let raw1 = decodeAddress(addr1),
+            raw2 = decodeAddress(addr2);
+        if (!raw1 || !raw2)
+            return false;
+        else {
+            if (typeof raw1.bech_version !== 'undefined' && raw1.bytes.length == 32) //bech32-multisig
+                raw1.hex = Crypto.util.bytesToHex(ripemd160(raw1.bytes, { asBytes: true }));
+            if (typeof raw2.bech_version !== 'undefined' && raw2.bytes.length == 32) //bech32-multisig
+                raw2.hex = Crypto.util.bytesToHex(ripemd160(raw2.bytes, { asBytes: true }));
+            return raw1.hex === raw2.hex;
+        }
+    }
+
+    const decodeAddress = floCrypto.decodeAddr = function (address) {
+        if (!address)
+            return;
+        else if (address.length == 33 || address.length == 34) { //legacy encoding
+            let decode = bitjs.Base58.decode(address);
+            let bytes = decode.slice(0, decode.length - 4);
+            let checksum = decode.slice(decode.length - 4),
+                hash = Crypto.SHA256(Crypto.SHA256(bytes, {
+                    asBytes: true
+                }), {
+                    asBytes: true
+                });
+            return (hash[0] != checksum[0] || hash[1] != checksum[1] || hash[2] != checksum[2] || hash[3] != checksum[3]) ? null : {
+                version: bytes.shift(),
+                hex: Crypto.util.bytesToHex(bytes),
+                bytes
+            }
+        } else if (address.length == 42 || address.length == 62) { //bech encoding
+            let decode = coinjs.bech32_decode(address);
+            if (decode) {
+                let bytes = decode.data;
+                let bech_version = bytes.shift();
+                bytes = coinjs.bech32_convert(bytes, 5, 8, false);
+                return {
+                    bech_version,
+                    hrp: decode.hrp,
+                    hex: Crypto.util.bytesToHex(bytes),
+                    bytes
+                }
+            } else
+                return null;
+        }
+    }
+
+    //Split the str using shamir's Secret and Returns the shares 
+    floCrypto.createShamirsSecretShares = function (str, total_shares, threshold_limit) {
+        try {
+            if (str.length > 0) {
+                var strHex = shamirSecretShare.str2hex(str);
+                var shares = shamirSecretShare.share(strHex, total_shares, threshold_limit);
+                return shares;
+            }
+            return false;
+        } catch {
+            return false
+        }
+    }
+
+    //Returns the retrived secret by combining the shamirs shares
+    const retrieveShamirSecret = floCrypto.retrieveShamirSecret = function (sharesArray) {
+        try {
+            if (sharesArray.length > 0) {
+                var comb = shamirSecretShare.combine(sharesArray.slice(0, sharesArray.length));
+                comb = shamirSecretShare.hex2str(comb);
+                return comb;
+            }
+            return false;
+        } catch {
+            return false;
+        }
+    }
+
+    //Verifies the shares and str
+    floCrypto.verifyShamirsSecret = function (sharesArray, str) {
+        if (!str)
+            return null;
+        else if (retrieveShamirSecret(sharesArray) === str)
+            return true;
+        else
+            return false;
+    }
+
+    const validateASCII = floCrypto.validateASCII = function (string, bool = true) {
+        if (typeof string !== "string")
+            return null;
+        if (bool) {
+            let x;
+            for (let i = 0; i < string.length; i++) {
+                x = string.charCodeAt(i);
+                if (x < 32 || x > 127)
+                    return false;
+            }
+            return true;
+        } else {
+            let x, invalids = {};
+            for (let i = 0; i < string.length; i++) {
+                x = string.charCodeAt(i);
+                if (x < 32 || x > 127)
+                    if (x in invalids)
+                        invalids[string[i]].push(i)
+                    else
+                        invalids[string[i]] = [i];
+            }
+            if (Object.keys(invalids).length)
+                return invalids;
+            else
+                return true;
+        }
+    }
+
+    floCrypto.convertToASCII = function (string, mode = 'soft-remove') {
+        let chars = validateASCII(string, false);
+        if (chars === true)
+            return string;
+        else if (chars === null)
+            return null;
+        let convertor, result = string,
+            refAlt = {};
+        ascii_alternatives.split('\n').forEach(a => refAlt[a[0]] = a.slice(2));
+        mode = mode.toLowerCase();
+        if (mode === "hard-unicode")
+            convertor = (c) => `\\u${('000' + c.charCodeAt().toString(16)).slice(-4)}`;
+        else if (mode === "soft-unicode")
+            convertor = (c) => refAlt[c] || `\\u${('000' + c.charCodeAt().toString(16)).slice(-4)}`;
+        else if (mode === "hard-remove")
+            convertor = c => "";
+        else if (mode === "soft-remove")
+            convertor = c => refAlt[c] || "";
+        else
+            return null;
+        for (let c in chars)
+            result = result.replaceAll(c, convertor(c));
+        return result;
+    }
+
+    floCrypto.revertUnicode = function (string) {
+        return string.replace(/\\u[\dA-F]{4}/gi,
+            m => String.fromCharCode(parseInt(m.replace(/\\u/g, ''), 16)));
+    }
+
+})('object' === typeof module ? module.exports : window.floCrypto = {});

scripts/floDapps.js

@@ -0,0 +1,891 @@
+(function (EXPORTS) { //floDapps v2.4.1
+    /* General functions for FLO Dapps*/
+    'use strict';
+    const floDapps = EXPORTS;
+
+    const DEFAULT = {
+        root: "floDapps",
+        application: floGlobals.application,
+        adminID: floGlobals.adminID
+    };
+
+    Object.defineProperties(floDapps, {
+        application: {
+            get: () => DEFAULT.application
+        },
+        adminID: {
+            get: () => DEFAULT.adminID
+        },
+        root: {
+            get: () => DEFAULT.root
+        }
+    });
+
+    var user_priv_raw, aes_key, user_priv_wrap; //private variable inside capsule
+    const raw_user = {
+        get private() {
+            if (!user_priv_raw)
+                throw "User not logged in";
+            return Crypto.AES.decrypt(user_priv_raw, aes_key);
+        }
+    }
+
+    var user_id, user_public, user_private;
+    const user = floDapps.user = {
+        get id() {
+            if (!user_id)
+                throw "User not logged in";
+            return user_id;
+        },
+        get public() {
+            if (!user_public)
+                throw "User not logged in";
+            return user_public;
+        },
+        get private() {
+            if (!user_private)
+                throw "User not logged in";
+            else if (user_private instanceof Function)
+                return user_private();
+            else
+                return Crypto.AES.decrypt(user_private, aes_key);
+        },
+        sign(message) {
+            return floCrypto.signData(message, raw_user.private);
+        },
+        decrypt(data) {
+            return floCrypto.decryptData(data, raw_user.private);
+        },
+        encipher(message) {
+            return Crypto.AES.encrypt(message, raw_user.private);
+        },
+        decipher(data) {
+            return Crypto.AES.decrypt(data, raw_user.private);
+        },
+        get db_name() {
+            return "floDapps#" + floCrypto.toFloID(user.id);
+        },
+        lock() {
+            user_private = user_priv_wrap;
+        },
+        async unlock() {
+            if (await user.private === raw_user.private)
+                user_private = user_priv_raw;
+        },
+        get_contact(id) {
+            if (!user.contacts)
+                throw "Contacts not available";
+            else if (user.contacts[id])
+                return user.contacts[id];
+            else {
+                let id_raw = floCrypto.decodeAddr(id).hex;
+                for (let i in user.contacts)
+                    if (floCrypto.decodeAddr(i).hex == id_raw)
+                        return user.contacts[i];
+            }
+        },
+        get_pubKey(id) {
+            if (!user.pubKeys)
+                throw "Contacts not available";
+            else if (user.pubKeys[id])
+                return user.pubKeys[id];
+            else {
+                let id_raw = floCrypto.decodeAddr(id).hex;
+                for (let i in user.pubKeys)
+                    if (floCrypto.decodeAddr(i).hex == id_raw)
+                        return user.pubKeys[i];
+            }
+        },
+        clear() {
+            user_id = user_public = user_private = undefined;
+            user_priv_raw = aes_key = undefined;
+            delete user.contacts;
+            delete user.pubKeys;
+            delete user.messages;
+        }
+    };
+
+    Object.defineProperties(window, {
+        myFloID: {
+            get: () => {
+                try {
+                    return user.id;
+                } catch {
+                    return;
+                }
+            }
+        },
+        myUserID: {
+            get: () => {
+                try {
+                    return user.id;
+                } catch {
+                    return;
+                }
+            }
+        },
+        myPubKey: {
+            get: () => {
+                try {
+                    return user.public;
+                } catch {
+                    return;
+                }
+            }
+        },
+        myPrivKey: {
+            get: () => {
+                try {
+                    return user.private;
+                } catch {
+                    return;
+                }
+            }
+        }
+    });
+
+    var subAdmins = [], trustedIDs = [], settings = {};
+    Object.defineProperties(floGlobals, {
+        subAdmins: {
+            get: () => subAdmins
+        },
+        trustedIDs: {
+            get: () => trustedIDs
+        },
+        settings: {
+            get: () => settings
+        },
+        contacts: {
+            get: () => user.contacts
+        },
+        pubKeys: {
+            get: () => user.pubKeys
+        },
+        messages: {
+            get: () => user.messages
+        }
+    })
+
+    function initIndexedDB() {
+        return new Promise((resolve, reject) => {
+            var obs_g = {
+                //general
+                lastTx: {},
+                //supernode (cloud list)
+                supernodes: {}
+            }
+            var obs_a = {
+                //login credentials
+                credentials: {},
+                //for Dapps
+                subAdmins: {},
+                trustedIDs: {},
+                settings: {},
+                appObjects: {},
+                generalData: {},
+                lastVC: {}
+            }
+            //add other given objectStores
+            initIndexedDB.appObs = initIndexedDB.appObs || {}
+            for (let o in initIndexedDB.appObs)
+                if (!(o in obs_a))
+                    obs_a[o] = initIndexedDB.appObs[o]
+            Promise.all([
+                compactIDB.initDB(DEFAULT.application, obs_a),
+                compactIDB.initDB(DEFAULT.root, obs_g)
+            ]).then(result => {
+                compactIDB.setDefaultDB(DEFAULT.application)
+                resolve("IndexedDB App Storage Initated Successfully")
+            }).catch(error => reject(error));
+        })
+    }
+
+    function initUserDB() {
+        return new Promise((resolve, reject) => {
+            var obs = {
+                contacts: {},
+                pubKeys: {},
+                messages: {}
+            }
+            compactIDB.initDB(user.db_name, obs).then(result => {
+                resolve("UserDB Initated Successfully")
+            }).catch(error => reject('Init userDB failed'));
+        })
+    }
+
+    function loadUserDB() {
+        return new Promise((resolve, reject) => {
+            var loadData = ["contacts", "pubKeys", "messages"]
+            var promises = []
+            for (var i = 0; i < loadData.length; i++)
+                promises[i] = compactIDB.readAllData(loadData[i], user.db_name)
+            Promise.all(promises).then(results => {
+                for (var i = 0; i < loadData.length; i++)
+                    user[loadData[i]] = results[i]
+                resolve("Loaded Data from userDB")
+            }).catch(error => reject('Load userDB failed'))
+        })
+    }
+
+    const startUpOptions = {
+        cloud: true,
+        app_config: true,
+    }
+
+    floDapps.startUpOptions = {
+        set app_config(val) {
+            if (val === true || val === false)
+                startUpOptions.app_config = val;
+        },
+        get app_config() { return startUpOptions.app_config },
+
+        set cloud(val) {
+            if (val === true || val === false)
+                startUpOptions.cloud = val;
+        },
+        get cloud() { return startUpOptions.cloud },
+    }
+
+    const startUpFunctions = [];
+
+    startUpFunctions.push(function readSupernodeListFromAPI() {
+        return new Promise((resolve) => {
+            if (!startUpOptions.cloud)
+                return resolve("No cloud for this app");
+
+            const CLOUD_KEY = "floCloudAPI#" + floCloudAPI.SNStorageID;
+
+            // Fallback: init from cached nodes (never reject)
+            const initFromCache = (tag) =>
+                compactIDB.readData("supernodes", CLOUD_KEY, DEFAULT.root)
+                    .then(nodes => {
+                        nodes = nodes || {};
+                        return floCloudAPI.init(nodes)
+                            .then(r => resolve(`${tag} (from cache)\n${r}`))
+                            .catch(() => resolve(`${tag} (cache present, init skipped)`));
+                    })
+                    .catch(() => resolve(`${tag} (no cache)`));
+
+            compactIDB.readData("lastTx", CLOUD_KEY, DEFAULT.root).then(lastTx => {
+                const query_options = { sentOnly: true, pattern: floCloudAPI.SNStorageName };
+                if (typeof lastTx === 'number')  // backward support (tx count)
+                    query_options.ignoreOld = lastTx;
+                else if (typeof lastTx === 'string') // last txid
+                    query_options.after = lastTx;
+
+                // Try online; if it fails, fall back to cache
+                floBlockchainAPI.readData(floCloudAPI.SNStorageID, query_options).then(result => {
+                    compactIDB.readData("supernodes", CLOUD_KEY, DEFAULT.root).then(nodes => {
+                        nodes = nodes || {};
+                        for (let i = result.data.length - 1; i >= 0; i--) {
+                            const content = JSON.parse(result.data[i])[floCloudAPI.SNStorageName];
+                            if (!content || typeof content !== 'object') continue;
+                            if (content.removeNodes)
+                                for (let sn in content.removeNodes) delete nodes[sn];
+                            if (content.newNodes)
+                                for (let sn in content.newNodes) nodes[sn] = content.newNodes[sn];
+                            if (content.updateNodes)
+                                for (let sn in content.updateNodes)
+                                    if (sn in nodes) nodes[sn].uri = content.updateNodes[sn];
+                        }
+                        Promise.all([
+                            compactIDB.writeData("lastTx", result.lastItem, CLOUD_KEY, DEFAULT.root),
+                            compactIDB.writeData("supernodes", nodes, CLOUD_KEY, DEFAULT.root)
+                        ]).then(() => {
+                            floCloudAPI.init(nodes)
+                                .then(r => resolve("Loaded Supernode list\n" + r))
+                                .catch(() => resolve("Loaded Supernode list (init deferred)"));
+                        }).catch(() => resolve("Supernode list updated (persist partial)"));
+                    }).catch(() => initFromCache("Supernode list read failed"));
+                }).catch(() => initFromCache("Supernode network fetch failed"));
+            }).catch(() => initFromCache("Supernode lastTx read failed"));
+        });
+    });
+
+
+    startUpFunctions.push(function readAppConfigFromAPI() {
+        return new Promise((resolve) => {
+            if (!startUpOptions.app_config)
+                return resolve("No configs for this app");
+
+            // small helper: load cached directives into memory and resolve
+            const loadFromIDB = (msg) => Promise.all([
+                compactIDB.readAllData("subAdmins"),
+                compactIDB.readAllData("trustedIDs"),
+                compactIDB.readAllData("settings")
+            ]).then(([sub, trust, set]) => {
+                subAdmins  = Object.keys(sub || {});   // arrays of IDs
+                trustedIDs = Object.keys(trust || {});
+                settings   = set || {};
+                resolve(msg);
+            }).catch(() => {
+                // safe defaults if cache missing
+                subAdmins = []; trustedIDs = []; settings = {};
+                resolve(msg + " (no local cache)");
+            });
+
+            // If cloud is disabled, use cached config and move on
+            if (!startUpOptions.cloud)
+                return loadFromIDB("Read app configuration from local cache (offline)");
+
+            const lastKey = `${DEFAULT.application}|${DEFAULT.adminID}`;
+
+            // Try to read lastTx; on failure, just use cache (don’t block startup)
+            compactIDB.readData("lastTx", lastKey, DEFAULT.root).then(lastTx => {
+                const query_options = { sentOnly: true, pattern: DEFAULT.application };
+                if (typeof lastTx === 'number') query_options.ignoreOld = lastTx;
+                else if (typeof lastTx === 'string') query_options.after = lastTx;
+
+                // Fetch deltas from chain; on failure, fall back to cache
+                floBlockchainAPI.readData(DEFAULT.adminID, query_options).then(result => {
+                    for (let i = result.data.length - 1; i >= 0; i--) {
+                        const content = JSON.parse(result.data[i])[DEFAULT.application];
+                        if (!content || typeof content !== "object") continue;
+
+                        if (Array.isArray(content.removeSubAdmin))
+                            for (let j = 0; j < content.removeSubAdmin.length; j++)
+                                compactIDB.removeData("subAdmins", content.removeSubAdmin[j]);
+
+                        if (Array.isArray(content.addSubAdmin))
+                            for (let k = 0; k < content.addSubAdmin.length; k++)
+                                compactIDB.writeData("subAdmins", true, content.addSubAdmin[k]);
+
+                        if (Array.isArray(content.removeTrustedID))
+                            for (let j = 0; j < content.removeTrustedID.length; j++)
+                                compactIDB.removeData("trustedIDs", content.removeTrustedID[j]);
+
+                        if (Array.isArray(content.addTrustedID))
+                            for (let k = 0; k < content.addTrustedID.length; k++)
+                                compactIDB.writeData("trustedIDs", true, content.addTrustedID[k]);
+
+                        if (content.settings)
+                            for (let l in content.settings)
+                                compactIDB.writeData("settings", content.settings[l], l);
+                    }
+
+                    // persist last item marker (best effort)
+                    compactIDB.writeData("lastTx", result.lastItem, lastKey, DEFAULT.root).catch(() => {});
+
+                    // load fresh values from IDB into memory and finish
+                    loadFromIDB("Read app configuration from blockchain");
+                }).catch(() => {
+                    // network failed → boot from cache
+                    loadFromIDB("Read app configuration from local cache (network fail)");
+                });
+            }).catch(() => {
+                // couldn't read lastTx → still boot from cache
+                loadFromIDB("Read app configuration from local cache (no lastTx)");
+            });
+        });
+    });
+
+
+    startUpFunctions.push(function loadDataFromAppIDB() {
+        return new Promise((resolve, reject) => {
+            const loadData = ["appObjects", "generalData", "lastVC"];
+
+            // If cloud is disabled AND no IDB stores are expected, skip early
+            if (!startUpOptions.cloud && (!initIndexedDB.appObs || Object.keys(initIndexedDB.appObs).length === 0))
+                return resolve("No cloud and no local data to load");
+
+            // Otherwise, read from IDB
+            Promise.all(loadData.map(item => compactIDB.readAllData(item)))
+                .then(results => {
+                    for (let i = 0; i < loadData.length; i++)
+                        floGlobals[loadData[i]] = results[i];
+                    resolve("Loaded Data from app IDB");
+                })
+                .catch(error => reject(error));
+        });
+    });
+
+    var keyInput = type => new Promise((resolve, reject) => {
+        let inputVal = prompt(`Enter ${type}: `)
+        if (inputVal === null)
+            reject(null)
+        else
+            resolve(inputVal)
+    });
+
+    function getCredentials() {
+
+        const readSharesFromIDB = indexArr => new Promise((resolve, reject) => {
+            var promises = []
+            for (var i = 0; i < indexArr.length; i++)
+                promises.push(compactIDB.readData('credentials', indexArr[i]))
+            Promise.all(promises).then(shares => {
+                var secret = floCrypto.retrieveShamirSecret(shares)
+                if (secret)
+                    resolve(secret)
+                else
+                    reject("Shares are insufficient or incorrect")
+            }).catch(error => {
+                clearCredentials();
+                location.reload();
+            })
+        });
+
+        const writeSharesToIDB = (shares, i = 0, resultIndexes = []) => new Promise(resolve => {
+            if (i >= shares.length)
+                return resolve(resultIndexes)
+            var n = floCrypto.randInt(0, 100000)
+            compactIDB.addData("credentials", shares[i], n).then(res => {
+                resultIndexes.push(n)
+                writeSharesToIDB(shares, i + 1, resultIndexes)
+                    .then(result => resolve(result))
+            }).catch(error => {
+                writeSharesToIDB(shares, i, resultIndexes)
+                    .then(result => resolve(result))
+            })
+        });
+
+        const getPrivateKeyCredentials = () => new Promise((resolve, reject) => {
+            var indexArr = localStorage.getItem(`${DEFAULT.application}#privKey`)
+            if (indexArr) {
+                readSharesFromIDB(JSON.parse(indexArr))
+                    .then(result => resolve(result))
+                    .catch(error => reject(error))
+            } else {
+                var privKey;
+                keyInput("PRIVATE_KEY").then(result => {
+                    if (!result)
+                        return reject("Empty Private Key")
+                    var floID = floCrypto.getFloID(result)
+                    if (!floID || !floCrypto.validateFloID(floID))
+                        return reject("Invalid Private Key")
+                    privKey = result;
+                }).catch(error => {
+                    console.log(error, "Generating Random Keys")
+                    privKey = floCrypto.generateNewID().privKey
+                }).finally(_ => {
+                    if (!privKey)
+                        return;
+                    var threshold = floCrypto.randInt(10, 20)
+                    var shares = floCrypto.createShamirsSecretShares(privKey, threshold, threshold)
+                    writeSharesToIDB(shares).then(resultIndexes => {
+                        //store index keys in localStorage
+                        localStorage.setItem(`${DEFAULT.application}#privKey`, JSON.stringify(resultIndexes))
+                        //also add a dummy privatekey to the IDB
+                        var randomPrivKey = floCrypto.generateNewID().privKey
+                        var randomThreshold = floCrypto.randInt(10, 20)
+                        var randomShares = floCrypto.createShamirsSecretShares(randomPrivKey, randomThreshold, randomThreshold)
+                        writeSharesToIDB(randomShares)
+                        //resolve private Key
+                        resolve(privKey)
+                    })
+                })
+            }
+        });
+
+        const checkIfPinRequired = key => new Promise((resolve, reject) => {
+            if (key.length == 52)
+                resolve(key)
+            else {
+                keyInput("PIN/Password").then(pwd => {
+                    try {
+                        let privKey = Crypto.AES.decrypt(key, pwd);
+                        resolve(privKey)
+                    } catch (error) {
+                        reject("Access Denied: Incorrect PIN/Password")
+                    }
+                }).catch(error => reject("Access Denied: PIN/Password required"))
+            }
+        });
+
+        return new Promise((resolve, reject) => {
+            getPrivateKeyCredentials().then(key => {
+                checkIfPinRequired(key).then(privKey => {
+                    try {
+                        user_public = floCrypto.getPubKeyHex(privKey);
+                        user_id = floCrypto.getAddress(privKey);
+                        if (startUpOptions.cloud)
+                            floCloudAPI.user(user_id, privKey); //Set user for floCloudAPI
+                        user_priv_wrap = () => checkIfPinRequired(key);
+                        let n = floCrypto.randInt(12, 20);
+                        aes_key = floCrypto.randString(n);
+                        user_priv_raw = Crypto.AES.encrypt(privKey, aes_key);
+                        user_private = user_priv_wrap;
+                        resolve('Login Credentials loaded successful')
+                    } catch (error) {
+                        console.log(error)
+                        reject("Corrupted Private Key")
+                    }
+                }).catch(error => reject(error))
+            }).catch(error => reject(error))
+        })
+    }
+
+    var startUpLog = (status, log) => status ? console.log(log) : console.error(log);
+
+    const callStartUpFunction = i => new Promise((resolve, reject) => {
+        startUpFunctions[i]().then(result => {
+            callStartUpFunction.completed += 1;
+            startUpLog(true, `${result}\nCompleted ${callStartUpFunction.completed}/${callStartUpFunction.total} Startup functions`)
+            resolve(true)
+        }).catch(error => {
+            callStartUpFunction.failed += 1;
+            startUpLog(false, `${error}\nFailed ${callStartUpFunction.failed}/${callStartUpFunction.total} Startup functions`)
+            reject(false)
+        })
+    });
+
+    var _midFunction;
+    const midStartUp = () => new Promise((res, rej) => {
+        if (_midFunction instanceof Function) {
+            _midFunction()
+                .then(r => res("Mid startup function completed"))
+                .catch(e => rej("Mid startup function failed"))
+        } else
+            res("No mid startup function")
+    });
+
+    const callAndLog = p => new Promise((res, rej) => {
+        p.then(r => {
+            startUpLog(true, r)
+            res(r)
+        }).catch(e => {
+            startUpLog(false, e)
+            rej(e)
+        })
+    });
+
+    floDapps.launchStartUp = function () {
+        return new Promise((resolve, reject) => {
+            initIndexedDB().then(log => {
+                console.log(log)
+                callStartUpFunction.total = startUpFunctions.length;
+                callStartUpFunction.completed = 0;
+                callStartUpFunction.failed = 0;
+                let p1 = new Promise((res, rej) => {
+                    Promise.all(startUpFunctions.map((f, i) => callStartUpFunction(i))).then(r => {
+                        callAndLog(midStartUp())
+                            .then(r => res(true))
+                            .catch(e => rej(false))
+                    })
+                });
+                let p2 = new Promise((res, rej) => {
+                    callAndLog(getCredentials()).then(r => {
+                        callAndLog(initUserDB()).then(r => {
+                            callAndLog(loadUserDB())
+                                .then(r => res(true))
+                                .catch(e => rej(false))
+                        }).catch(e => rej(false))
+                    }).catch(e => rej(false))
+                })
+                Promise.all([p1, p2])
+                    .then(r => resolve('App Startup finished successful'))
+                    .catch(e => reject('App Startup failed'))
+            }).catch(error => {
+                startUpLog(false, error);
+                reject("App database initiation failed")
+            })
+        })
+    }
+
+    floDapps.addStartUpFunction = fn => fn instanceof Function && !startUpFunctions.includes(fn) ? startUpFunctions.push(fn) : false;
+
+    floDapps.setMidStartup = fn => fn instanceof Function ? _midFunction = fn : false;
+
+    floDapps.setCustomStartupLogger = fn => fn instanceof Function ? startUpLog = fn : false;
+
+    floDapps.setCustomPrivKeyInput = fn => fn instanceof Function ? keyInput = fn : false;
+
+    floDapps.setAppObjectStores = appObs => initIndexedDB.appObs = appObs;
+
+    floDapps.storeContact = function (floID, name) {
+        return new Promise((resolve, reject) => {
+            if (!floCrypto.validateAddr(floID))
+                return reject("Invalid floID!")
+            compactIDB.writeData("contacts", name, floID, user.db_name).then(result => {
+                user.contacts[floID] = name;
+                resolve("Contact stored")
+            }).catch(error => reject(error))
+        });
+    }
+
+    floDapps.storePubKey = function (floID, pubKey) {
+        return new Promise((resolve, reject) => {
+            if (floID in user.pubKeys)
+                return resolve("pubKey already stored")
+            if (!floCrypto.validateAddr(floID))
+                return reject("Invalid floID!")
+            if (!floCrypto.verifyPubKey(pubKey, floID))
+                return reject("Incorrect pubKey")
+            compactIDB.writeData("pubKeys", pubKey, floID, user.db_name).then(result => {
+                user.pubKeys[floID] = pubKey;
+                resolve("pubKey stored")
+            }).catch(error => reject(error))
+        });
+    }
+
+    floDapps.sendMessage = function (floID, message) {
+        return new Promise((resolve, reject) => {
+            let options = {
+                receiverID: floID,
+                application: DEFAULT.root,
+                comment: DEFAULT.application
+            }
+            if (floID in user.pubKeys)
+                message = floCrypto.encryptData(JSON.stringify(message), user.pubKeys[floID])
+            floCloudAPI.sendApplicationData(message, "Message", options)
+                .then(result => resolve(result))
+                .catch(error => reject(error))
+        })
+    }
+
+    floDapps.requestInbox = function (callback) {
+        return new Promise((resolve, reject) => {
+            let lastVC = Object.keys(user.messages).sort().pop()
+            let options = {
+                receiverID: user.id,
+                application: DEFAULT.root,
+                lowerVectorClock: lastVC + 1
+            }
+            let privKey = raw_user.private;
+            options.callback = (d, e) => {
+                for (let v in d) {
+                    try {
+                        if (d[v].message instanceof Object && "secret" in d[v].message)
+                            d[v].message = floCrypto.decryptData(d[v].message, privKey)
+                    } catch (error) { }
+                    compactIDB.writeData("messages", d[v], v, user.db_name)
+                    user.messages[v] = d[v]
+                }
+                if (callback instanceof Function)
+                    callback(d, e)
+            }
+            floCloudAPI.requestApplicationData("Message", options)
+                .then(result => resolve(result))
+                .catch(error => reject(error))
+        })
+    }
+
+    floDapps.manageAppConfig = function (adminPrivKey, addList, rmList, settings) {
+        return new Promise((resolve, reject) => {
+            if (!startUpOptions.app_config)
+                return reject("No configs for this app");
+            if (!Array.isArray(addList) || !addList.length) addList = undefined;
+            if (!Array.isArray(rmList) || !rmList.length) rmList = undefined;
+            if (!settings || typeof settings !== "object" || !Object.keys(settings).length) settings = undefined;
+            if (!addList && !rmList && !settings)
+                return reject("No configuration change")
+            var floData = {
+                [DEFAULT.application]: {
+                    addSubAdmin: addList,
+                    removeSubAdmin: rmList,
+                    settings: settings
+                }
+            }
+            var floID = floCrypto.getFloID(adminPrivKey)
+            if (floID != DEFAULT.adminID)
+                reject('Access Denied for Admin privilege')
+            else
+                floBlockchainAPI.writeData(floID, JSON.stringify(floData), adminPrivKey)
+                    .then(result => resolve(['Updated App Configuration', result]))
+                    .catch(error => reject(error))
+        })
+    }
+
+    floDapps.manageAppTrustedIDs = function (adminPrivKey, addList, rmList) {
+        return new Promise((resolve, reject) => {
+            if (!startUpOptions.app_config)
+                return reject("No configs for this app");
+            if (!Array.isArray(addList) || !addList.length) addList = undefined;
+            if (!Array.isArray(rmList) || !rmList.length) rmList = undefined;
+            if (!addList && !rmList)
+                return reject("No change in list")
+            var floData = {
+                [DEFAULT.application]: {
+                    addTrustedID: addList,
+                    removeTrustedID: rmList
+                }
+            }
+            var floID = floCrypto.getFloID(adminPrivKey)
+            if (floID != DEFAULT.adminID)
+                reject('Access Denied for Admin privilege')
+            else
+                floBlockchainAPI.writeData(floID, JSON.stringify(floData), adminPrivKey)
+                    .then(result => resolve(['Updated App Configuration', result]))
+                    .catch(error => reject(error))
+        })
+    }
+
+    const clearCredentials = floDapps.clearCredentials = function () {
+        return new Promise((resolve, reject) => {
+            compactIDB.clearData('credentials', DEFAULT.application).then(result => {
+                localStorage.removeItem(`${DEFAULT.application}#privKey`);
+                user.clear();
+                resolve("privKey credentials deleted!")
+            }).catch(error => reject(error))
+        })
+    }
+
+    floDapps.deleteUserData = function (credentials = false) {
+        return new Promise((resolve, reject) => {
+            let p = []
+            p.push(compactIDB.deleteDB(user.db_name))
+            if (credentials)
+                p.push(clearCredentials())
+            Promise.all(p)
+                .then(result => resolve('User database(local) deleted'))
+                .catch(error => reject(error))
+        })
+    }
+
+    floDapps.deleteAppData = function () {
+        return new Promise((resolve, reject) => {
+            compactIDB.deleteDB(DEFAULT.application).then(result => {
+                localStorage.removeItem(`${DEFAULT.application}#privKey`)
+                user.clear();
+                compactIDB.removeData('lastTx', `${DEFAULT.application}|${DEFAULT.adminID}`, DEFAULT.root)
+                    .then(result => resolve("App database(local) deleted"))
+                    .catch(error => reject(error))
+            }).catch(error => reject(error))
+        })
+    }
+
+    floDapps.securePrivKey = function (pwd) {
+        return new Promise(async (resolve, reject) => {
+            let indexArr = localStorage.getItem(`${DEFAULT.application}#privKey`)
+            if (!indexArr)
+                return reject("PrivKey not found");
+            indexArr = JSON.parse(indexArr)
+            let encryptedKey = Crypto.AES.encrypt(await user.private, pwd);
+            let threshold = indexArr.length;
+            let shares = floCrypto.createShamirsSecretShares(encryptedKey, threshold, threshold)
+            let promises = [];
+            let overwriteFn = (share, index) =>
+                compactIDB.writeData("credentials", share, index, DEFAULT.application);
+            for (var i = 0; i < threshold; i++)
+                promises.push(overwriteFn(shares[i], indexArr[i]));
+            Promise.all(promises)
+                .then(results => resolve("Private Key Secured"))
+                .catch(error => reject(error))
+        })
+    }
+
+    floDapps.verifyPin = function (pin = null) {
+        const readSharesFromIDB = function (indexArr) {
+            return new Promise((resolve, reject) => {
+                var promises = []
+                for (var i = 0; i < indexArr.length; i++)
+                    promises.push(compactIDB.readData('credentials', indexArr[i]))
+                Promise.all(promises).then(shares => {
+                    var secret = floCrypto.retrieveShamirSecret(shares)
+                    console.info(shares, secret)
+                    if (secret)
+                        resolve(secret)
+                    else
+                        reject("Shares are insufficient or incorrect")
+                }).catch(error => {
+                    clearCredentials();
+                    location.reload();
+                })
+            })
+        }
+        return new Promise((resolve, reject) => {
+            var indexArr = localStorage.getItem(`${DEFAULT.application}#privKey`)
+            console.info(indexArr)
+            if (!indexArr)
+                reject('No login credentials found')
+            readSharesFromIDB(JSON.parse(indexArr)).then(key => {
+                if (key.length == 52) {
+                    if (pin === null)
+                        resolve("Private key not secured")
+                    else
+                        reject("Private key not secured")
+                } else {
+                    if (pin === null)
+                        return reject("PIN/Password required")
+                    try {
+                        let privKey = Crypto.AES.decrypt(key, pin);
+                        resolve("PIN/Password verified")
+                    } catch (error) {
+                        reject("Incorrect PIN/Password")
+                    }
+                }
+            }).catch(error => reject(error))
+        })
+    }
+
+    const getNextGeneralData = floDapps.getNextGeneralData = function (type, vectorClock = null, options = {}) {
+        var fk = floCloudAPI.util.filterKey(type, options)
+        vectorClock = vectorClock || getNextGeneralData[fk] || '0';
+        var filteredResult = {}
+        if (floGlobals.generalData[fk]) {
+            for (let d in floGlobals.generalData[fk])
+                if (d > vectorClock)
+                    filteredResult[d] = JSON.parse(JSON.stringify(floGlobals.generalData[fk][d]))
+        } else if (options.comment) {
+            let comment = options.comment;
+            delete options.comment;
+            let fk = floCloudAPI.util.filterKey(type, options);
+            for (let d in floGlobals.generalData[fk])
+                if (d > vectorClock && floGlobals.generalData[fk][d].comment == comment)
+                    filteredResult[d] = JSON.parse(JSON.stringify(floGlobals.generalData[fk][d]))
+        }
+        if (options.decrypt) {
+            let decryptionKey = (options.decrypt === true) ? raw_user.private : options.decrypt;
+            if (!Array.isArray(decryptionKey))
+                decryptionKey = [decryptionKey];
+            for (let f in filteredResult) {
+                let data = filteredResult[f]
+                try {
+                    if (data.message instanceof Object && "secret" in data.message) {
+                        for (let key of decryptionKey) {
+                            try {
+                                let tmp = floCrypto.decryptData(data.message, key)
+                                data.message = JSON.parse(tmp)
+                                break;
+                            } catch (error) { }
+                        }
+                    }
+                } catch (error) { }
+            }
+        }
+        getNextGeneralData[fk] = Object.keys(filteredResult).sort().pop();
+        return filteredResult;
+    }
+
+    const syncData = floDapps.syncData = {};
+
+    syncData.oldDevice = () => new Promise((resolve, reject) => {
+        let sync = {
+            contacts: user.contacts,
+            pubKeys: user.pubKeys,
+            messages: user.messages
+        }
+        let message = Crypto.AES.encrypt(JSON.stringify(sync), raw_user.private)
+        let options = {
+            receiverID: user.id,
+            application: DEFAULT.root
+        }
+        floCloudAPI.sendApplicationData(message, "syncData", options)
+            .then(result => resolve(result))
+            .catch(error => reject(error))
+    });
+
+    syncData.newDevice = () => new Promise((resolve, reject) => {
+        var options = {
+            receiverID: user.id,
+            senderID: user.id,
+            application: DEFAULT.root,
+            mostRecent: true,
+        }
+        floCloudAPI.requestApplicationData("syncData", options).then(response => {
+            let vc = Object.keys(response).sort().pop()
+            let sync = JSON.parse(Crypto.AES.decrypt(response[vc].message, raw_user.private))
+            let promises = []
+            let store = (key, val, obs) => promises.push(compactIDB.writeData(obs, val, key, user.db_name));
+            ["contacts", "pubKeys", "messages"].forEach(c => {
+                for (let i in sync[c]) {
+                    store(i, sync[c][i], c)
+                    user[c][i] = sync[c][i]
+                }
+            })
+            Promise.all(promises)
+                .then(results => resolve("Sync data successful"))
+                .catch(error => reject(error))
+        }).catch(error => reject(error))
+    });
+})('object' === typeof module ? module.exports : window.floDapps = {});

template/css/main.css

@@ -0,0 +1,443 @@
+* {
+  padding: 0;
+  margin: 0;
+  -webkit-box-sizing: border-box;
+  box-sizing: border-box;
+  font-family: "Inter", sans-serif;
+}
+
+:root {
+  font-size: clamp(1rem, 1.2vmax, 1.2rem);
+}
+
+html,
+body {
+  height: 100%;
+  scroll-behavior: smooth;
+}
+
+body {
+  color: rgba(var(--text-color), 1);
+  background: var(--foreground-color);
+}
+
+body,
+body * {
+  --accent-color: rgb(0, 156, 78);
+  --text-color: 36, 36, 36;
+  --background-color: 248, 248, 248;
+  --foreground-color: rgb(255, 255, 255);
+  --danger-color: rgb(255, 75, 75);
+  --like-color: #e91e63;
+  scrollbar-width: thin;
+}
+
+body[data-theme=dark],
+body[data-theme=dark] * {
+  --accent-color: rgb(14, 230, 122);
+  --text-color: 230, 230, 230;
+  --text-color-light: 170, 170, 170;
+  --background-color: 10, 10, 10;
+  --foreground-color: rgb(24, 24, 24);
+  --danger-color: rgb(255, 106, 106);
+}
+
+body[data-theme=dark] sm-popup::part(popup) {
+  background-color: var(--foreground-color);
+}
+
+p {
+  font-size: 0.9rem;
+  max-width: 70ch;
+  color: rgba(var(--text-color), 0.8);
+}
+
+p * {
+  font-family: inherit;
+}
+
+.flex {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+}
+
+.direction-column {
+  -webkit-box-orient: vertical;
+  -webkit-box-direction: normal;
+      -ms-flex-direction: column;
+          flex-direction: column;
+}
+
+.grid {
+  display: grid;
+}
+
+.flow-column {
+  grid-auto-flow: column;
+}
+
+.gap-0-5 {
+  gap: 0.5rem;
+}
+
+.gap-1 {
+  gap: 1rem;
+}
+
+.gap-1-5 {
+  gap: 1.5rem;
+}
+
+.gap-2 {
+  gap: 2rem;
+}
+
+.gap-3 {
+  gap: 3rem;
+}
+
+.justify-self-center {
+  justify-self: center;
+}
+
+.justify-self-start {
+  justify-self: start;
+}
+
+.justify-self-end {
+  justify-self: end;
+}
+
+.icon {
+  width: 1.2rem;
+  height: 1.2rem;
+  fill: rgba(var(--text-color), 0.8);
+  -ms-flex-negative: 0;
+      flex-shrink: 0;
+}
+
+button,
+.button {
+  -webkit-user-select: none;
+     -moz-user-select: none;
+      -ms-user-select: none;
+          user-select: none;
+  position: relative;
+  display: -webkit-inline-box;
+  display: -ms-inline-flexbox;
+  display: inline-flex;
+  border: none;
+  background-color: transparent;
+  overflow: hidden;
+  color: inherit;
+  cursor: pointer;
+  -webkit-transition: -webkit-transform 0.3s;
+  transition: -webkit-transform 0.3s;
+  transition: transform 0.3s;
+  transition: transform 0.3s, -webkit-transform 0.3s;
+  -webkit-tap-highlight-color: transparent;
+  -webkit-box-align: center;
+      -ms-flex-align: center;
+          align-items: center;
+  font-size: 0.9rem;
+  font-weight: 500;
+}
+
+.button {
+  white-space: nowrap;
+  padding: 0.6rem 1rem;
+  border-radius: 0.3rem;
+  background-color: rgba(var(--text-color), 0.06);
+  color: rgba(var(--text-color), 0.8);
+  -webkit-box-pack: center;
+      -ms-flex-pack: center;
+          justify-content: center;
+}
+.button--primary {
+  background-color: var(--accent-color);
+  color: rgba(var(--background-color), 1);
+}
+
+button:active,
+.button:active,
+sm-button:not([disabled]):active,
+.interact:active {
+  -webkit-transform: scale(0.9);
+          transform: scale(0.9);
+}
+
+.popup__header {
+  display: grid;
+  gap: 0.5rem;
+  width: 100%;
+  padding: 0 1.5rem 0 0.5rem;
+  -webkit-box-align: center;
+      -ms-flex-align: center;
+          align-items: center;
+  grid-template-columns: auto 1fr auto;
+}
+
+.popup__header__close {
+  padding: 0.5rem;
+}
+
+#sign_in,
+#sign_up {
+  -webkit-box-align: center;
+      -ms-flex-align: center;
+          align-items: center;
+}
+#sign_in sm-form,
+#sign_up sm-form {
+  margin: 2rem 0;
+  --gap: 1rem;
+}
+#sign_in header,
+#sign_up header {
+  padding: 1.5rem 0;
+}
+
+#sign_up sm-copy {
+  font-size: 0.9rem;
+}
+#sign_up h5 {
+  font-weight: 500;
+  color: rgba(var(--text-color), 0.8);
+}
+
+.card {
+  padding: 1rem;
+  border-radius: 0.5rem;
+  background-color: rgba(var(--text-color), 0.04);
+}
+
+.warning {
+  background-color: khaki;
+  color: rgba(0, 0, 0, 0.7);
+  padding: 1rem;
+  border-radius: 0.5rem;
+  line-height: 1.5;
+}
+
+#main_header {
+  display: grid;
+  gap: 1rem;
+  position: sticky;
+  top: 0;
+  padding: 1rem;
+  -webkit-box-align: center;
+      -ms-flex-align: center;
+          align-items: center;
+  grid-template-columns: 1fr auto auto;
+  background-color: var(--foreground-color);
+  z-index: 1;
+}
+
+.logo {
+  display: grid;
+  -webkit-box-align: center;
+      -ms-flex-align: center;
+          align-items: center;
+  width: 100%;
+  grid-template-columns: auto 1fr;
+  gap: 0 0.5rem;
+  margin-right: 1rem;
+}
+
+.logo h4 {
+  text-transform: capitalize;
+  font-size: 0.9rem;
+  font-weight: 500;
+}
+
+.main-logo {
+  height: 1.4rem;
+  width: 1.4rem;
+  fill: rgba(var(--text-color), 1);
+  stroke: none;
+}
+
+article {
+  position: relative;
+  padding-bottom: 3rem;
+  gap: 1rem;
+}
+article::after {
+  justify-self: center;
+  position: absolute;
+  bottom: 0;
+  content: "";
+  width: 4rem;
+  height: 0.3rem;
+  border-radius: 0.5rem;
+  background-color: rgba(var(--text-color), 0.5);
+}
+article p {
+  font-family: "noto serif", serif;
+  line-height: 1.8;
+  font-size: 1rem;
+}
+
+.page-layout {
+  display: grid;
+  grid-template-columns: 1rem minmax(0, 1fr) 1rem;
+}
+
+.page-layout > * {
+  grid-column: 2/3;
+}
+
+.hero-section {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr);
+  margin-bottom: 1.5rem;
+  padding-top: 1.5rem;
+}
+
+img {
+  -o-object-fit: cover;
+     object-fit: cover;
+  width: 100%;
+  height: 40vh;
+}
+
+time {
+  font-size: 0.8rem;
+}
+
+h1 {
+  font-size: 1.4rem;
+  margin-bottom: 1rem;
+}
+
+h3:not(:first-of-type) {
+  margin-top: 2rem;
+}
+
+.full-bleed {
+  grid-column: 1/-1;
+}
+
+.quote-template {
+  position: relative;
+  padding: 1rem;
+  margin: 1rem 0;
+  border-radius: 0.2rem;
+  border: solid thin rgba(var(--text-color), 0.3);
+  -webkit-box-shadow: 0.3rem 0.5rem 0 0.1rem rgba(var(--text-color), 0.8);
+          box-shadow: 0.3rem 0.5rem 0 0.1rem rgba(var(--text-color), 0.8);
+  overflow: hidden;
+  justify-self: center;
+  padding-left: 1.3rem;
+}
+
+.quote-template figcaption {
+  margin-top: 0.5rem;
+  color: rgba(var(--text-color), 0.8);
+  font-size: 0.8rem;
+  margin-left: auto;
+}
+
+.upvote {
+  display: grid;
+  grid-template-columns: auto 1fr;
+  position: relative;
+  padding: 0.8rem;
+  border-radius: 2rem;
+  background-color: var(--foreground-color);
+  -webkit-box-shadow: 0 0.5rem 1rem rgba(0, 0, 0, 0.1);
+          box-shadow: 0 0.5rem 1rem rgba(0, 0, 0, 0.1);
+  border: solid rgba(var(--text-color), 0.2) thin;
+}
+.upvote > * {
+  pointer-events: none;
+}
+.upvote:active {
+  -webkit-transform: none;
+          transform: none;
+}
+.upvote:active .icon {
+  -webkit-transform: scale(0.7);
+          transform: scale(0.7);
+}
+.upvote.liked {
+  background-color: var(--like-color);
+  color: white;
+}
+.upvote.liked .icon {
+  fill: white;
+}
+
+.expanding-heart,
+.ring {
+  grid-area: 1/1;
+}
+
+.ring {
+  border: 0.1rem solid var(--like-color);
+  border-radius: 50%;
+  height: 0.5rem;
+  width: 0.5rem;
+  justify-self: center;
+}
+
+.upvote .icon {
+  grid-area: 1/1;
+  fill: var(--like-color);
+  height: 1.5rem;
+  width: 1.5rem;
+  -webkit-transition: -webkit-transform 0.2s;
+  transition: -webkit-transform 0.2s;
+  transition: transform 0.2s;
+  transition: transform 0.2s, -webkit-transform 0.2s;
+}
+
+.temp-count,
+#like_count {
+  grid-area: 1/2;
+}
+.temp-count:not(:empty),
+#like_count:not(:empty) {
+  margin-left: 0.4rem;
+}
+
+footer {
+  padding: 3rem 1.5rem;
+  justify-items: center;
+}
+
+@media screen and (min-width: 40rem) {
+  sm-popup {
+    --width: 24rem;
+  }
+
+  .popup__header {
+    padding: 1rem 1.5rem 0 1rem;
+  }
+
+  .page-layout {
+    grid-template-columns: 1fr 60ch 1fr;
+  }
+
+  h1 {
+    font-size: 2rem;
+  }
+}
+@media (any-hover: hover) {
+  ::-webkit-scrollbar {
+    width: 0.5rem;
+    height: 0.5rem;
+  }
+
+  ::-webkit-scrollbar-thumb {
+    background: rgba(var(--text-color), 0.3);
+    border-radius: 1rem;
+  }
+  ::-webkit-scrollbar-thumb:hover {
+    background: rgba(var(--text-color), 0.5);
+  }
+}
+.hide-completely {
+  display: none;
+}

template/css/main.scss

@@ -0,0 +1,396 @@
+* {
+  padding: 0;
+  margin: 0;
+  -webkit-box-sizing: border-box;
+  box-sizing: border-box;
+  font-family: "Inter", sans-serif;
+}
+
+:root {
+  font-size: clamp(1rem, 1.2vmax, 1.2rem);
+}
+
+html,
+body {
+  height: 100%;
+  scroll-behavior: smooth;
+}
+
+body {
+  color: rgba(var(--text-color), 1);
+  background: var(--foreground-color);
+}
+
+body,
+body * {
+  --accent-color: rgb(0, 156, 78);
+  --text-color: 36, 36, 36;
+  --background-color: 248, 248, 248;
+  --foreground-color: rgb(255, 255, 255);
+  --danger-color: rgb(255, 75, 75);
+  --like-color: #e91e63;
+  scrollbar-width: thin;
+}
+
+body[data-theme="dark"],
+body[data-theme="dark"] * {
+  --accent-color: rgb(14, 230, 122);
+  --text-color: 230, 230, 230;
+  --text-color-light: 170, 170, 170;
+  --background-color: 10, 10, 10;
+  --foreground-color: rgb(24, 24, 24);
+  --danger-color: rgb(255, 106, 106);
+}
+
+body[data-theme="dark"] sm-popup::part(popup) {
+  background-color: var(--foreground-color);
+}
+
+p {
+  font-size: 0.9rem;
+  max-width: 70ch;
+  color: rgba(var(--text-color), 0.8);
+}
+
+p * {
+  font-family: inherit;
+}
+
+.flex {
+  display: flex;
+}
+.direction-column {
+  flex-direction: column;
+}
+
+.grid {
+  display: grid;
+}
+
+.flow-column {
+  grid-auto-flow: column;
+}
+
+.gap-0-5 {
+  gap: 0.5rem;
+}
+
+.gap-1 {
+  gap: 1rem;
+}
+
+.gap-1-5 {
+  gap: 1.5rem;
+}
+
+.gap-2 {
+  gap: 2rem;
+}
+
+.gap-3 {
+  gap: 3rem;
+}
+.justify-self-center {
+  justify-self: center;
+}
+
+.justify-self-start {
+  justify-self: start;
+}
+
+.justify-self-end {
+  justify-self: end;
+}
+
+.icon {
+  width: 1.2rem;
+  height: 1.2rem;
+  fill: rgba(var(--text-color), 0.8);
+  flex-shrink: 0;
+}
+
+button,
+.button {
+  user-select: none;
+  position: relative;
+  display: inline-flex;
+  border: none;
+  background-color: transparent;
+  overflow: hidden;
+  color: inherit;
+  cursor: pointer;
+  transition: transform 0.3s;
+  -webkit-tap-highlight-color: transparent;
+  align-items: center;
+  font-size: 0.9rem;
+  font-weight: 500;
+}
+.button {
+  white-space: nowrap;
+  padding: 0.6rem 1rem;
+  border-radius: 0.3rem;
+  background-color: rgba(var(--text-color), 0.06);
+  color: rgba(var(--text-color), 0.8);
+  justify-content: center;
+  &--primary {
+    background-color: var(--accent-color);
+    color: rgba(var(--background-color), 1);
+  }
+}
+
+button:active,
+.button:active,
+sm-button:not([disabled]):active,
+.interact:active {
+  transform: scale(0.9);
+}
+.popup__header {
+  display: grid;
+  gap: 0.5rem;
+  width: 100%;
+  padding: 0 1.5rem 0 0.5rem;
+  align-items: center;
+  grid-template-columns: auto 1fr auto;
+}
+.popup__header__close {
+  padding: 0.5rem;
+}
+
+#sign_in,
+#sign_up {
+  align-items: center;
+  sm-form {
+    margin: 2rem 0;
+    --gap: 1rem;
+  }
+  header {
+    padding: 1.5rem 0;
+  }
+}
+#sign_up {
+  sm-copy {
+    font-size: 0.9rem;
+  }
+  h5 {
+    font-weight: 500;
+    color: rgba(var(--text-color), 0.8);
+  }
+}
+.card {
+  padding: 1rem;
+  border-radius: 0.5rem;
+  background-color: rgba(var(--text-color), 0.04);
+}
+.warning {
+  background-color: khaki;
+  color: rgba(0, 0, 0, 0.7);
+  padding: 1rem;
+  border-radius: 0.5rem;
+  line-height: 1.5;
+}
+
+#main_header {
+  display: grid;
+  gap: 1rem;
+  position: sticky;
+  top: 0;
+  padding: 1rem;
+  align-items: center;
+  grid-template-columns: 1fr auto auto;
+  background-color: var(--foreground-color);
+  z-index: 1;
+}
+
+.logo {
+  display: grid;
+  align-items: center;
+  width: 100%;
+  grid-template-columns: auto 1fr;
+  gap: 0 0.5rem;
+  margin-right: 1rem;
+}
+
+.logo h4 {
+  text-transform: capitalize;
+  font-size: 0.9rem;
+  font-weight: 500;
+}
+
+.main-logo {
+  height: 1.4rem;
+  width: 1.4rem;
+  fill: rgba(var(--text-color), 1);
+  stroke: none;
+}
+
+article {
+  position: relative;
+  padding-bottom: 3rem;
+  gap: 1rem;
+  &::after {
+    justify-self: center;
+    position: absolute;
+    bottom: 0;
+    content: "";
+    width: 4rem;
+    height: 0.3rem;
+    border-radius: 0.5rem;
+    background-color: rgba(var(--text-color), 0.5);
+  }
+  p {
+    font-family: "noto serif", serif;
+    line-height: 1.8;
+    font-size: 1rem;
+  }
+}
+
+.page-layout {
+  display: grid;
+  grid-template-columns: 1rem minmax(0, 1fr) 1rem;
+}
+
+.page-layout > * {
+  grid-column: 2/3;
+}
+
+.hero-section {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr);
+  margin-bottom: 1.5rem;
+  padding-top: 1.5rem;
+}
+
+img {
+  object-fit: cover;
+  width: 100%;
+  height: 40vh;
+}
+
+time {
+  font-size: 0.8rem;
+}
+
+h1 {
+  font-size: 1.4rem;
+  margin-bottom: 1rem;
+}
+
+h3:not(:first-of-type) {
+  margin-top: 2rem;
+}
+
+.full-bleed {
+  grid-column: 1/-1;
+}
+
+.quote-template {
+  position: relative;
+  padding: 1rem;
+  margin: 1rem 0;
+  border-radius: 0.2rem;
+  border: solid thin rgba(var(--text-color), 0.3);
+  box-shadow: 0.3rem 0.5rem 0 0.1rem rgba(var(--text-color), 0.8);
+  overflow: hidden;
+  justify-self: center;
+  padding-left: 1.3rem;
+}
+
+.quote-template figcaption {
+  margin-top: 0.5rem;
+  color: rgba(var(--text-color), 0.8);
+  font-size: 0.8rem;
+  margin-left: auto;
+}
+
+.upvote {
+  display: grid;
+  grid-template-columns: auto 1fr;
+  position: relative;
+  padding: 0.8rem;
+  border-radius: 2rem;
+  background-color: var(--foreground-color);
+  box-shadow: 0 0.5rem 1rem rgba(0, 0, 0, 0.1);
+  border: solid rgba(var(--text-color), 0.2) thin;
+  & > * {
+    pointer-events: none;
+  }
+  &:active {
+    transform: none;
+    .icon {
+      transform: scale(0.7);
+    }
+  }
+  &.liked {
+    background-color: var(--like-color);
+    color: white;
+    .icon {
+      fill: white;
+    }
+  }
+}
+.expanding-heart,
+.ring {
+  grid-area: 1/1;
+}
+.ring {
+  border: 0.1rem solid var(--like-color);
+  border-radius: 50%;
+  height: 0.5rem;
+  width: 0.5rem;
+  justify-self: center;
+}
+.upvote .icon {
+  grid-area: 1/1;
+  fill: var(--like-color);
+  height: 1.5rem;
+  width: 1.5rem;
+  transition: transform 0.2s;
+}
+.temp-count,
+#like_count {
+  grid-area: 1/2;
+  &:not(:empty) {
+    margin-left: 0.4rem;
+  }
+}
+
+footer {
+  padding: 3rem 1.5rem;
+  justify-items: center;
+}
+
+@media screen and (min-width: 40rem) {
+  sm-popup {
+    --width: 24rem;
+  }
+  .popup__header {
+    padding: 1rem 1.5rem 0 1rem;
+  }
+  .page-layout {
+    grid-template-columns: 1fr 60ch 1fr;
+  }
+
+  h1 {
+    font-size: 2rem;
+  }
+}
+@media (any-hover: hover) {
+  ::-webkit-scrollbar {
+    width: 0.5rem;
+    height: 0.5rem;
+  }
+
+  ::-webkit-scrollbar-thumb {
+    background: rgba(var(--text-color), 0.3);
+    border-radius: 1rem;
+
+    &:hover {
+      background: rgba(var(--text-color), 0.5);
+    }
+  }
+}
+
+// highest priority styles
+.hide-completely {
+  display: none;
+}