Workflow updating files of flowallet

flowallet/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Sai Raj
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

flowallet/README.md

@@ -0,0 +1,76 @@
+# FLO Wallet
+FLO Web Wallet
+
+These are client-side scripts that can generate FLO addresses, send FLO transactions to the blockchain and monitor FLO data from the blockchain
+
+NOTE: Use respective file for mainnet and testnet  
+
+### Live URL for FLO Wallet:
+*https://ranchimall.github.io/flowallet/*  
+
+## Instructions to use 
+
+Note: Web wallet uses IndedxedDB for storing data, which means data is stored in the respective browser you used to open web wallet. Data stored by one browser can't be accessed by other browsers.
+
+There are 4 pages in this web app :
+----------------------
+
+### Monitor FLO Data
+
+This app allows users to view the transactions done by the given address/es.
+1. Click/Tap on the '+' floating button at bottom-right hand side, which opens a popup window.
+
+2. Enter the FLO address that you want to monitor, You can also specify a label for that address which will be displayed as a name for that address. If you left the label field empty, the default label will be 'Unknown'.
+
+3. Click/Tap on 'Ok' and the address you added will be displayed on the monitoring page as a card. This address is also added to your local database. Once you add an address/label pair, It will stay there until you clear data(Option available on Settings page).
+
+4. When you hover the mouse pointer on a monitoring card, three dots will appear. clicking on this allows the user to edit or remove that address from the monitoring list.(On mobile devices this option is always visible)
+
+5. To see transactions done by any address, click/Tap on the respective address card. It will open a follow-up window, which displays transactions in the message format. consisting of data sent/received to/from, date of transaction, and FLO data. Arrows on the message body indicate the direction of the transaction i.e. Data is sent or received. On the top of the window, we have the option to go back to the monitoring page or refresh the transaction history.
+
+### Send FLO Data
+
+This page allows users to send FLO data and transactions to the blockchain. To send any data you have to check your balance first, to make sure you have enough balance as each transaction requires 0.0005 FLOs to be valid.
+
+1. Enter the sender's address
+2. Click check balance.
+3. Balance of the respective address will be displayed
+4. Enter the Receiver's address
+5. Enter the amount 
+6. Enter FLO data (if required)
+7. Click Send
+8. Enter the private key for the address in the prompt
+9. The transaction will be sent to the blockchain and returns the txid (returns error if any).
+
+Note: Transaction fee is set to 0.0005
+
+### FLO address generation/recovery page
+This page can be used to generate or recover FLO addresses and private key pairs. This page has two buttons 
+#### generate a new address
+As the name implies this button when clicked/tapped generates a new FLO address and private key pair. Also, there is a one-click/tap option that allows the user to copy the FLO address or private key.
+
+#### Recover FLO address 
+This button when click/tapped opens a popup, which prompts the user to enter private key associated with the FLO address that has to be recovered. Once the correct private key is entered corresponding FLO address is displayed again.
+
+Note: Do not share your private key with anyone and keep it safe. Once lost a private key can't be recovered.
+
+### Settings page
+
+This page contains settings and information about Webapp.
+
+#### Dark mode setting
+
+This section allows the user to set a color scheme (light/dark) with two options, either automatic or manual.
+ 1. Automatic - If this toggle is turned on, Dark mode is enabled automatically from 6 pm to 6 am (Custom timing will be added in future versions).
+ 
+ 2. Manual - Turning this toggle on/off changes the color scheme and stays in that mode unless changed by the user again.
+
+#### CLear all local data
+
+This option clears all the data stored in IndexedDB databases from the browser. This is the same as clearing browser data and cache. After deleting data, it may take more time to load transactions as they are now fetched again from the blockchain. Also, you have to add addresses to start monitoring again.
+
+#### About 
+This section contains information about the version and underlying technologies.
+
+
+Note: For reducing API calls and processing time, monitored data are stored in the local browser. While monitoring the same address, the data from the browser database (IndexedDB) is used and only the new transactions are obtained using API.

flowallet/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 = {});

flowallet/scripts/flo-webwallet.js

@@ -0,0 +1,144 @@
+(function (EXPORTS) {
+    /*FLO Web Wallet operations*/
+    'use strict';
+    const floWebWallet = EXPORTS;
+
+    //generate a new Address triplet : resolves Object(floID,pubKey,privKey)
+    floWebWallet.generateNewAddr = function () {
+        return new Promise((resolve, reject) => {
+            try {
+                var triplet = floCrypto.generateNewID();
+                resolve(triplet);
+            } catch (error) {
+                reject(error);
+            }
+        })
+    }
+
+    //recover triplet from given privKey : resolves Object(floID,pubKey,privKey)
+    floWebWallet.recoverAddr = function (privKey) {
+        return new Promise((resolve, reject) => {
+            try {
+                var triplet = {}
+                triplet.privKey = privKey;
+                triplet.pubKey = floCrypto.getPubKeyHex(triplet.privKey);
+                triplet.floID = floCrypto.getFloID(triplet.pubKey);
+                resolve(triplet);
+            } catch (error) {
+                reject(error);
+            }
+        })
+    }
+
+    //get balance of address using API : resolves (balance)
+    floWebWallet.getBalance = function (address) {
+        return new Promise((resolve, reject) => {
+            floBlockchainAPI.getBalance(address)
+                .then(txid => resolve(txid))
+                .catch(error => reject(error))
+        })
+    }
+
+    //send transaction to the blockchain using API : resolves (txid)
+    floWebWallet.sendTransaction = function (sender, receiver, amount, floData, privKey) {
+        return new Promise((resolve, reject) => {
+            floBlockchainAPI.sendTx(sender, receiver, amount, privKey, floData)
+                .then(txid => resolve(txid))
+                .catch(error => reject(error))
+        })
+    }
+
+    function formatTx(address, tx) {
+        let result = {
+            time: tx.time,
+            block: tx.blockheight,
+            blockhash: tx.blockhash,
+            txid: tx.txid,
+            floData: tx.floData,
+            confirmations: tx.confirmations
+        }
+
+        //format receivers
+        let receivers = {};
+        for (let vout of tx.vout) {
+            if (vout.scriptPubKey.isAddress) {
+                let id = vout.scriptPubKey.addresses[0];
+                if (id in receivers)
+                    receivers[id] += vout.value;
+                else receivers[id] = vout.value;
+            }
+        }
+        result.receivers = receivers;
+        //format senders (or mined)
+        if (!tx.vin[0].isAddress) { //mined (ie, coinbase)
+            let coinbase = tx.vin[0].coinbase;
+            result.mine = coinbase;
+            result.mined = { [coinbase]: tx.valueOut }
+        } else {
+            result.sender = tx.vin[0].addresses[0];
+            result.receiver = tx.vout[0].scriptPubKey.addresses[0];
+            result.fees = tx.fees;
+            let senders = {};
+            for (let vin of tx.vin) {
+                if (vin.isAddress) {
+                    let id = vin.addresses[0];
+                    if (id in senders)
+                        senders[id] += vin.value;
+                    else senders[id] = vin.value;
+                }
+            }
+            result.senders = senders;
+
+            //remove change amounts
+            for (let id in senders) {
+                if (id in receivers) {
+                    if (senders[id] > receivers[id]) {
+                        senders[id] -= receivers[id];
+                        delete receivers[id];
+                    } else if (senders[id] < receivers[id]) { //&& id != address 
+                        receivers[id] -= senders[id];
+                        delete senders[id];
+                    }
+                }
+            }
+        }
+
+        return result;
+    }
+
+    floWebWallet.listTransactions = function (address, page_options = {}) {
+        return new Promise((resolve, reject) => {
+            let options = {};
+            if (Number.isInteger(page_options.page))
+                options.page = page_options.page;
+            if (Number.isInteger(page_options.pageSize))
+                options.pageSize = page_options.pageSize;
+            floBlockchainAPI.readTxs(address, options).then(response => {
+                const result = {}
+                result.items = response.txs.map(tx => formatTx(address, tx));
+                result.page = response.page;
+                result.totalPages = response.totalPages;
+                resolve(result);
+            }).catch(error => reject(error))
+        })
+    }
+
+    //get address-label pairs from IDB : resolves Object(floID:label)
+    floWebWallet.getLabels = function () {
+        return new Promise((resolve, reject) => {
+            compactIDB.readAllData('labels')
+                .then(IDBresult => resolve(IDBresult))
+                .catch(error => reject(error))
+        })
+    }
+
+    //bulk transfer tokens
+    floWebWallet.bulkTransferTokens = function (sender, privKey, token, receivers) {
+        return new Promise((resolve, reject) => {
+            floTokenAPI.bulkTransferTokens(sender, privKey, token, receivers)
+                .then(result => resolve(result))
+                .catch(error => reject(error))
+        })
+    }
+
+})(window.floWebWallet = {});

flowallet/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 = {});

flowallet/scripts/floTokenAPI.js

@@ -0,0 +1,166 @@
+(function (EXPORTS) { //floTokenAPI v1.0.4a
+    /* Token Operator to send/receive tokens via blockchain using API calls*/
+    'use strict';
+    const tokenAPI = EXPORTS;
+
+    const DEFAULT = {
+        apiURL: floGlobals.tokenURL || "https://ranchimallflo.duckdns.org/",
+        currency: floGlobals.currency || "rupee"
+    }
+
+    Object.defineProperties(tokenAPI, {
+        URL: {
+            get: () => DEFAULT.apiURL
+        },
+        currency: {
+            get: () => DEFAULT.currency,
+            set: currency => DEFAULT.currency = currency
+        }
+    });
+
+    if (floGlobals.currency) tokenAPI.currency = floGlobals.currency;
+
+    Object.defineProperties(floGlobals, {
+        currency: {
+            get: () => DEFAULT.currency,
+            set: currency => DEFAULT.currency = currency
+        }
+    });
+
+    const fetch_api = tokenAPI.fetch = function (apicall) {
+        return new Promise((resolve, reject) => {
+            console.debug(DEFAULT.apiURL + apicall);
+            fetch(DEFAULT.apiURL + apicall).then(response => {
+                if (response.ok)
+                    response.json().then(data => resolve(data));
+                else
+                    reject(response)
+            }).catch(error => reject(error))
+        })
+    }
+
+    const getBalance = tokenAPI.getBalance = function (floID, token = DEFAULT.currency) {
+        return new Promise((resolve, reject) => {
+            fetch_api(`api/v1.0/getFloAddressBalance?token=${token}&floAddress=${floID}`)
+                .then(result => resolve(result.balance || 0))
+                .catch(error => reject(error))
+        })
+    }
+
+    tokenAPI.getTx = function (txID) {
+        return new Promise((resolve, reject) => {
+            fetch_api(`api/v1.0/getTransactionDetails/${txID}`).then(res => {
+                if (res.result === "error")
+                    reject(res.description);
+                else if (!res.parsedFloData)
+                    reject("Data piece (parsedFloData) missing");
+                else if (!res.transactionDetails)
+                    reject("Data piece (transactionDetails) missing");
+                else
+                    resolve(res);
+            }).catch(error => reject(error))
+        })
+    }
+
+    tokenAPI.sendToken = function (privKey, amount, receiverID, message = "", token = DEFAULT.currency, options = {}) {
+        return new Promise((resolve, reject) => {
+            let senderID = floCrypto.getFloID(privKey);
+            if (typeof amount !== "number" || isNaN(amount) || amount <= 0)
+                return reject("Invalid amount");
+            getBalance(senderID, token).then(bal => {
+                if (amount > bal)
+                    return reject(`Insufficient ${token}# balance`);
+                floBlockchainAPI.writeData(senderID, `send ${amount} ${token}# ${message}`, privKey, receiverID, options)
+                    .then(txid => resolve(txid))
+                    .catch(error => reject(error))
+            }).catch(error => reject(error))
+        });
+    }
+
+    function sendTokens_raw(privKey, receiverID, token, amount, utxo, vout, scriptPubKey) {
+        return new Promise((resolve, reject) => {
+            var trx = bitjs.transaction();
+            trx.addinput(utxo, vout, scriptPubKey)
+            trx.addoutput(receiverID, floBlockchainAPI.sendAmt);
+            trx.addflodata(`send ${amount} ${token}#`);
+            var signedTxHash = trx.sign(privKey, 1);
+            floBlockchainAPI.broadcastTx(signedTxHash)
+                .then(txid => resolve([receiverID, txid]))
+                .catch(error => reject([receiverID, error]))
+        })
+    }
+
+    //bulk transfer tokens
+    tokenAPI.bulkTransferTokens = function (sender, privKey, token, receivers) {
+        return new Promise((resolve, reject) => {
+            if (typeof receivers !== 'object')
+                return reject("receivers must be object in format {receiver1: amount1, receiver2:amount2...}")
+
+            let receiver_list = Object.keys(receivers), amount_list = Object.values(receivers);
+            let invalidReceivers = receiver_list.filter(id => !floCrypto.validateFloID(id));
+            let invalidAmount = amount_list.filter(val => typeof val !== 'number' || val <= 0);
+            if (invalidReceivers.length)
+                return reject(`Invalid receivers: ${invalidReceivers}`);
+            else if (invalidAmount.length)
+                return reject(`Invalid amounts: ${invalidAmount}`);
+
+            if (receiver_list.length == 0)
+                return reject("Receivers cannot be empty");
+
+            if (receiver_list.length == 1) {
+                let receiver = receiver_list[0], amount = amount_list[0];
+                floTokenAPI.sendToken(privKey, amount, receiver, "", token)
+                    .then(txid => resolve({ success: { [receiver]: txid } }))
+                    .catch(error => reject(error))
+            } else {
+                //check for token balance
+                floTokenAPI.getBalance(sender, token).then(token_balance => {
+                    let total_token_amout = amount_list.reduce((a, e) => a + e, 0);
+                    if (total_token_amout > token_balance)
+                        return reject(`Insufficient ${token}# balance`);
+
+                    //split utxos
+                    floBlockchainAPI.splitUTXOs(sender, privKey, receiver_list.length).then(split_txid => {
+                        //wait for the split utxo to get confirmation
+                        floBlockchainAPI.waitForConfirmation(split_txid).then(split_tx => {
+                            //send tokens using the split-utxo
+                            var scriptPubKey = split_tx.vout[0].scriptPubKey.hex;
+                            let promises = [];
+                            for (let i in receiver_list)
+                                promises.push(sendTokens_raw(privKey, receiver_list[i], token, amount_list[i], split_txid, i, scriptPubKey));
+                            Promise.allSettled(promises).then(results => {
+                                let success = Object.fromEntries(results.filter(r => r.status == 'fulfilled').map(r => r.value));
+                                let failed = Object.fromEntries(results.filter(r => r.status == 'rejected').map(r => r.reason));
+                                resolve({ success, failed });
+                            })
+                        }).catch(error => reject(error))
+                    }).catch(error => reject(error))
+                }).catch(error => reject(error))
+            }
+
+        })
+    }
+
+    tokenAPI.getAllTxs = function (floID, token = DEFAULT.currency) {
+        return new Promise((resolve, reject) => {
+            fetch_api(`api/v1.0/getFloAddressTransactions?token=${token}&floAddress=${floID}`)
+                .then(result => resolve(result))
+                .catch(error => reject(error))
+        })
+    }
+
+    const util = tokenAPI.util = {};
+
+    util.parseTxData = function (txData) {
+        let parsedData = {};
+        for (let p in txData.parsedFloData)
+            parsedData[p] = txData.parsedFloData[p];
+        parsedData.sender = txData.transactionDetails.vin[0].addr;
+        for (let vout of txData.transactionDetails.vout)
+            if (vout.scriptPubKey.addresses[0] !== parsedData.sender)
+                parsedData.receiver = vout.scriptPubKey.addresses[0];
+        parsedData.time = txData.transactionDetails.time;
+        return parsedData;
+    }
+
+})('object' === typeof module ? module.exports : window.floTokenAPI = {});