split files
This commit is contained in:
sairajzero
parent
8c2fb3a239
commit
2a0302eb19
10283
index.html
10283
index.html
File diff suppressed because it is too large
Load Diff
259
scripts/compactIDB.js
Normal file
259
scripts/compactIDB.js
Normal file
@ -0,0 +1,259 @@
|
||||
(function(EXPORTS) { //compactIDB v2.1.0
|
||||
/* 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) => {
|
||||
return true
|
||||
})
|
||||
options.limit = options.limit || 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 ? "prev" : "next");
|
||||
curReq.onsuccess = (evt) => {
|
||||
var cursor = evt.target.result;
|
||||
if (cursor) {
|
||||
if (options.patternEval(cursor.primaryKey, cursor.value)) {
|
||||
filteredResult[cursor.primaryKey] = cursor.value;
|
||||
options.lastOnly ? resolve(filteredResult) : cursor.continue();
|
||||
} else
|
||||
cursor.continue();
|
||||
} else
|
||||
resolve(filteredResult);
|
||||
}
|
||||
curReq.onerror = (evt) => reject(`Search unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`);
|
||||
db.close();
|
||||
}).catch(error => reject(error));
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
})(window.compactIDB = {});
|
||||
514
scripts/floBlockchainAPI.js
Normal file
514
scripts/floBlockchainAPI.js
Normal file
@ -0,0 +1,514 @@
|
||||
(function(EXPORTS) { //floBlockchainAPI v2.3.0
|
||||
/* FLO Blockchain Operator to send/receive data from blockchain using API calls*/
|
||||
'use strict';
|
||||
const floBlockchainAPI = EXPORTS;
|
||||
|
||||
const serverList = floGlobals.apiURL[floGlobals.blockchain].slice(0);
|
||||
var curPos = floCrypto.randInt(0, serverList - 1);
|
||||
|
||||
function fetch_retry(apicall, rm_flosight) {
|
||||
return new Promise((resolve, reject) => {
|
||||
let i = serverList.indexOf(rm_flosight)
|
||||
if (i != -1) serverList.splice(i, 1);
|
||||
curPos = floCrypto.randInt(0, serverList.length - 1);
|
||||
fetch_api(apicall)
|
||||
.then(result => resolve(result))
|
||||
.catch(error => reject(error));
|
||||
})
|
||||
}
|
||||
|
||||
function fetch_api(apicall) {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (serverList.length === 0)
|
||||
reject("No floSight server working");
|
||||
else {
|
||||
let flosight = serverList[curPos];
|
||||
fetch(flosight + apicall).then(response => {
|
||||
if (response.ok)
|
||||
response.json().then(data => resolve(data));
|
||||
else {
|
||||
fetch_retry(apicall, flosight)
|
||||
.then(result => resolve(result))
|
||||
.catch(error => reject(error));
|
||||
}
|
||||
}).catch(error => {
|
||||
fetch_retry(apicall, flosight)
|
||||
.then(result => resolve(result))
|
||||
.catch(error => reject(error));
|
||||
})
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
Object.defineProperty(floBlockchainAPI, 'current_server', {
|
||||
get: () => serverList[curPos]
|
||||
});
|
||||
|
||||
//Promised function to get data from API
|
||||
const promisedAPI = floBlockchainAPI.promisedAPI = function(apicall) {
|
||||
return new Promise((resolve, reject) => {
|
||||
//console.log(apicall);
|
||||
fetch_api(apicall)
|
||||
.then(result => resolve(result))
|
||||
.catch(error => reject(error));
|
||||
});
|
||||
}
|
||||
|
||||
//Get balance for the given Address
|
||||
const getBalance = floBlockchainAPI.getBalance = function(addr) {
|
||||
return new Promise((resolve, reject) => {
|
||||
promisedAPI(`api/addr/${addr}/balance`)
|
||||
.then(balance => resolve(parseFloat(balance)))
|
||||
.catch(error => reject(error));
|
||||
});
|
||||
}
|
||||
|
||||
//Send Tx to blockchain
|
||||
const sendTx = floBlockchainAPI.sendTx = function(senderAddr, receiverAddr, sendAmt, privKey, floData = '', strict_utxo = true) {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (!floCrypto.validateASCII(floData))
|
||||
return reject("Invalid FLO_Data: only printable ASCII characters are allowed");
|
||||
else if (!floCrypto.validateAddr(senderAddr))
|
||||
return reject(`Invalid address : ${senderAddr}`);
|
||||
else if (!floCrypto.validateAddr(receiverAddr))
|
||||
return reject(`Invalid address : ${receiverAddr}`);
|
||||
else if (privKey.length < 1 || !floCrypto.verifyPrivKey(privKey, senderAddr))
|
||||
return reject("Invalid Private key!");
|
||||
else if (typeof sendAmt !== 'number' || sendAmt <= 0)
|
||||
return reject(`Invalid sendAmt : ${sendAmt}`);
|
||||
|
||||
//get unconfirmed tx list
|
||||
promisedAPI(`api/addr/${senderAddr}`).then(result => {
|
||||
readTxs(senderAddr, 0, result.unconfirmedTxApperances).then(result => {
|
||||
let unconfirmedSpent = {};
|
||||
for (let tx of result.items)
|
||||
if (tx.confirmations == 0)
|
||||
for (let vin of tx.vin)
|
||||
if (vin.addr === senderAddr) {
|
||||
if (Array.isArray(unconfirmedSpent[vin.txid]))
|
||||
unconfirmedSpent[vin.txid].push(vin.vout);
|
||||
else
|
||||
unconfirmedSpent[vin.txid] = [vin.vout];
|
||||
}
|
||||
//get utxos list
|
||||
promisedAPI(`api/addr/${senderAddr}/utxo`).then(utxos => {
|
||||
//form/construct the transaction data
|
||||
var trx = bitjs.transaction();
|
||||
var utxoAmt = 0.0;
|
||||
var fee = floGlobals.fee;
|
||||
for (var i = utxos.length - 1;
|
||||
(i >= 0) && (utxoAmt < sendAmt + fee); i--) {
|
||||
//use only utxos with confirmations (strict_utxo mode)
|
||||
if (utxos[i].confirmations || !strict_utxo) {
|
||||
if (utxos[i].txid in unconfirmedSpent && unconfirmedSpent[utxos[i].txid].includes(utxos[i].vout))
|
||||
continue; //A transaction has already used the utxo, but is unconfirmed.
|
||||
trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i].scriptPubKey);
|
||||
utxoAmt += utxos[i].amount;
|
||||
};
|
||||
}
|
||||
if (utxoAmt < sendAmt + fee)
|
||||
reject("Insufficient FLO balance!");
|
||||
else {
|
||||
trx.addoutput(receiverAddr, sendAmt);
|
||||
var change = utxoAmt - sendAmt - fee;
|
||||
if (change > 0)
|
||||
trx.addoutput(senderAddr, change);
|
||||
trx.addflodata(floData.replace(/\n/g, ' '));
|
||||
var signedTxHash = trx.sign(privKey, 1);
|
||||
broadcastTx(signedTxHash)
|
||||
.then(txid => resolve(txid))
|
||||
.catch(error => reject(error))
|
||||
}
|
||||
}).catch(error => reject(error))
|
||||
}).catch(error => reject(error))
|
||||
}).catch(error => reject(error))
|
||||
});
|
||||
}
|
||||
|
||||
//Write Data into blockchain
|
||||
floBlockchainAPI.writeData = function(senderAddr, data, privKey, receiverAddr = floGlobals.adminID, strict_utxo = true) {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (typeof data != "string")
|
||||
data = JSON.stringify(data);
|
||||
sendTx(senderAddr, receiverAddr, floGlobals.sendAmt, privKey, data, strict_utxo)
|
||||
.then(txid => resolve(txid))
|
||||
.catch(error => reject(error));
|
||||
});
|
||||
}
|
||||
|
||||
//merge all UTXOs of a given floID into a single UTXO
|
||||
floBlockchainAPI.mergeUTXOs = function(floID, privKey, floData = '') {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (!floCrypto.validateAddr(floID))
|
||||
return reject(`Invalid floID`);
|
||||
if (!floCrypto.verifyPrivKey(privKey, floID))
|
||||
return reject("Invalid Private Key");
|
||||
if (!floCrypto.validateASCII(floData))
|
||||
return reject("Invalid FLO_Data: only printable ASCII characters are allowed");
|
||||
var trx = bitjs.transaction();
|
||||
var utxoAmt = 0.0;
|
||||
var fee = floGlobals.fee;
|
||||
promisedAPI(`api/addr/${floID}/utxo`).then(utxos => {
|
||||
for (var i = utxos.length - 1; i >= 0; i--)
|
||||
if (utxos[i].confirmations) {
|
||||
trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i].scriptPubKey);
|
||||
utxoAmt += utxos[i].amount;
|
||||
}
|
||||
trx.addoutput(floID, utxoAmt - fee);
|
||||
trx.addflodata(floData.replace(/\n/g, ' '));
|
||||
var signedTxHash = trx.sign(privKey, 1);
|
||||
broadcastTx(signedTxHash)
|
||||
.then(txid => resolve(txid))
|
||||
.catch(error => reject(error))
|
||||
}).catch(error => reject(error))
|
||||
})
|
||||
}
|
||||
|
||||
/**Write data into blockchain from (and/or) to multiple floID
|
||||
* @param {Array} senderPrivKeys List of sender private-keys
|
||||
* @param {string} data FLO data of the txn
|
||||
* @param {Array} receivers List of receivers
|
||||
* @param {boolean} preserveRatio (optional) preserve ratio or equal contribution
|
||||
* @return {Promise}
|
||||
*/
|
||||
floBlockchainAPI.writeDataMultiple = function(senderPrivKeys, data, receivers = [floGlobals.adminID], preserveRatio = true) {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (!Array.isArray(senderPrivKeys))
|
||||
return reject("Invalid senderPrivKeys: SenderPrivKeys must be Array");
|
||||
if (!preserveRatio) {
|
||||
let tmp = {};
|
||||
let amount = (floGlobals.sendAmt * receivers.length) / senderPrivKeys.length;
|
||||
senderPrivKeys.forEach(key => tmp[key] = amount);
|
||||
senderPrivKeys = tmp;
|
||||
}
|
||||
if (!Array.isArray(receivers))
|
||||
return reject("Invalid receivers: Receivers must be Array");
|
||||
else {
|
||||
let tmp = {};
|
||||
let amount = floGlobals.sendAmt;
|
||||
receivers.forEach(floID => tmp[floID] = amount);
|
||||
receivers = tmp
|
||||
}
|
||||
if (typeof data != "string")
|
||||
data = JSON.stringify(data);
|
||||
sendTxMultiple(senderPrivKeys, receivers, data)
|
||||
.then(txid => resolve(txid))
|
||||
.catch(error => reject(error))
|
||||
})
|
||||
}
|
||||
|
||||
/**Send Tx from (and/or) to multiple floID
|
||||
* @param {Array or Object} senderPrivKeys List of sender private-key (optional: with coins to be sent)
|
||||
* @param {Object} receivers List of receivers with respective amount to be sent
|
||||
* @param {string} floData FLO data of the txn
|
||||
* @return {Promise}
|
||||
*/
|
||||
const sendTxMultiple = floBlockchainAPI.sendTxMultiple = function(senderPrivKeys, receivers, floData = '') {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (!floCrypto.validateASCII(floData))
|
||||
return reject("Invalid FLO_Data: only printable ASCII characters are allowed");
|
||||
let senders = {},
|
||||
preserveRatio;
|
||||
//check for argument validations
|
||||
try {
|
||||
let invalids = {
|
||||
InvalidSenderPrivKeys: [],
|
||||
InvalidSenderAmountFor: [],
|
||||
InvalidReceiverIDs: [],
|
||||
InvalidReceiveAmountFor: []
|
||||
}
|
||||
let inputVal = 0,
|
||||
outputVal = 0;
|
||||
//Validate sender privatekeys (and send amount if passed)
|
||||
//conversion when only privateKeys are passed (preserveRatio mode)
|
||||
if (Array.isArray(senderPrivKeys)) {
|
||||
senderPrivKeys.forEach(key => {
|
||||
try {
|
||||
if (!key)
|
||||
invalids.InvalidSenderPrivKeys.push(key);
|
||||
else {
|
||||
let floID = floCrypto.getFloID(key);
|
||||
senders[floID] = {
|
||||
wif: key
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
invalids.InvalidSenderPrivKeys.push(key)
|
||||
}
|
||||
})
|
||||
preserveRatio = true;
|
||||
}
|
||||
//conversion when privatekeys are passed with send amount
|
||||
else {
|
||||
for (let key in senderPrivKeys) {
|
||||
try {
|
||||
if (!key)
|
||||
invalids.InvalidSenderPrivKeys.push(key);
|
||||
else {
|
||||
if (typeof senderPrivKeys[key] !== 'number' || senderPrivKeys[key] <= 0)
|
||||
invalids.InvalidSenderAmountFor.push(key);
|
||||
else
|
||||
inputVal += senderPrivKeys[key];
|
||||
let floID = floCrypto.getFloID(key);
|
||||
senders[floID] = {
|
||||
wif: key,
|
||||
coins: senderPrivKeys[key]
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
invalids.InvalidSenderPrivKeys.push(key)
|
||||
}
|
||||
}
|
||||
preserveRatio = false;
|
||||
}
|
||||
//Validate the receiver IDs and receive amount
|
||||
for (let floID in receivers) {
|
||||
if (!floCrypto.validateAddr(floID))
|
||||
invalids.InvalidReceiverIDs.push(floID);
|
||||
if (typeof receivers[floID] !== 'number' || receivers[floID] <= 0)
|
||||
invalids.InvalidReceiveAmountFor.push(floID);
|
||||
else
|
||||
outputVal += receivers[floID];
|
||||
}
|
||||
//Reject if any invalids are found
|
||||
for (let i in invalids)
|
||||
if (!invalids[i].length)
|
||||
delete invalids[i];
|
||||
if (Object.keys(invalids).length)
|
||||
return reject(invalids);
|
||||
//Reject if given inputVal and outputVal are not equal
|
||||
if (!preserveRatio && inputVal != outputVal)
|
||||
return reject(`Input Amount (${inputVal}) not equal to Output Amount (${outputVal})`);
|
||||
} catch (error) {
|
||||
return reject(error)
|
||||
}
|
||||
//Get balance of senders
|
||||
let promises = [];
|
||||
for (let floID in senders)
|
||||
promises.push(getBalance(floID));
|
||||
Promise.all(promises).then(results => {
|
||||
let totalBalance = 0,
|
||||
totalFee = floGlobals.fee,
|
||||
balance = {};
|
||||
//Divide fee among sender if not for preserveRatio
|
||||
if (!preserveRatio)
|
||||
var dividedFee = totalFee / Object.keys(senders).length;
|
||||
//Check if balance of each sender is sufficient enough
|
||||
let insufficient = [];
|
||||
for (let floID in senders) {
|
||||
balance[floID] = parseFloat(results.shift());
|
||||
if (isNaN(balance[floID]) || (preserveRatio && balance[floID] <= totalFee) ||
|
||||
(!preserveRatio && balance[floID] < senders[floID].coins + dividedFee))
|
||||
insufficient.push(floID);
|
||||
totalBalance += balance[floID];
|
||||
}
|
||||
if (insufficient.length)
|
||||
return reject({
|
||||
InsufficientBalance: insufficient
|
||||
})
|
||||
//Calculate totalSentAmount and check if totalBalance is sufficient
|
||||
let totalSendAmt = totalFee;
|
||||
for (floID in receivers)
|
||||
totalSendAmt += receivers[floID];
|
||||
if (totalBalance < totalSendAmt)
|
||||
return reject("Insufficient total Balance");
|
||||
//Get the UTXOs of the senders
|
||||
let promises = [];
|
||||
for (floID in senders)
|
||||
promises.push(promisedAPI(`api/addr/${floID}/utxo`));
|
||||
Promise.all(promises).then(results => {
|
||||
let wifSeq = [];
|
||||
var trx = bitjs.transaction();
|
||||
for (floID in senders) {
|
||||
let utxos = results.shift();
|
||||
let sendAmt;
|
||||
if (preserveRatio) {
|
||||
let ratio = (balance[floID] / totalBalance);
|
||||
sendAmt = totalSendAmt * ratio;
|
||||
} else
|
||||
sendAmt = senders[floID].coins + dividedFee;
|
||||
let wif = senders[floID].wif;
|
||||
let utxoAmt = 0.0;
|
||||
for (let i = utxos.length - 1;
|
||||
(i >= 0) && (utxoAmt < sendAmt); i--) {
|
||||
if (utxos[i].confirmations) {
|
||||
trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i].scriptPubKey);
|
||||
wifSeq.push(wif);
|
||||
utxoAmt += utxos[i].amount;
|
||||
}
|
||||
}
|
||||
if (utxoAmt < sendAmt)
|
||||
return reject("Insufficient balance:" + floID);
|
||||
let change = (utxoAmt - sendAmt);
|
||||
if (change > 0)
|
||||
trx.addoutput(floID, change);
|
||||
}
|
||||
for (floID in receivers)
|
||||
trx.addoutput(floID, receivers[floID]);
|
||||
trx.addflodata(floData.replace(/\n/g, ' '));
|
||||
for (let i = 0; i < wifSeq.length; i++)
|
||||
trx.signinput(i, wifSeq[i], 1);
|
||||
var signedTxHash = trx.serialize();
|
||||
broadcastTx(signedTxHash)
|
||||
.then(txid => resolve(txid))
|
||||
.catch(error => reject(error))
|
||||
}).catch(error => reject(error))
|
||||
}).catch(error => reject(error))
|
||||
})
|
||||
}
|
||||
|
||||
//Broadcast signed Tx in blockchain using API
|
||||
const broadcastTx = floBlockchainAPI.broadcastTx = function(signedTxHash) {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (signedTxHash.length < 1)
|
||||
return reject("Empty Signature");
|
||||
var url = serverList[curPos] + 'api/tx/send';
|
||||
fetch(url, {
|
||||
method: "POST",
|
||||
headers: {
|
||||
'Content-Type': 'application/json'
|
||||
},
|
||||
body: `{"rawtx":"${signedTxHash}"}`
|
||||
}).then(response => {
|
||||
if (response.ok)
|
||||
response.json().then(data => resolve(data.txid.result));
|
||||
else
|
||||
response.text().then(data => resolve(data));
|
||||
}).catch(error => reject(error));
|
||||
})
|
||||
}
|
||||
|
||||
floBlockchainAPI.getTx = function(txid) {
|
||||
return new Promise((resolve, reject) => {
|
||||
promisedAPI(`api/tx/${txid}`)
|
||||
.then(response => resolve(response))
|
||||
.catch(error => reject(error))
|
||||
})
|
||||
}
|
||||
|
||||
//Read Txs of Address between from and to
|
||||
const readTxs = floBlockchainAPI.readTxs = function(addr, from, to) {
|
||||
return new Promise((resolve, reject) => {
|
||||
promisedAPI(`api/addrs/${addr}/txs?from=${from}&to=${to}`)
|
||||
.then(response => resolve(response))
|
||||
.catch(error => reject(error))
|
||||
});
|
||||
}
|
||||
|
||||
//Read All Txs of Address (newest first)
|
||||
floBlockchainAPI.readAllTxs = function(addr) {
|
||||
return new Promise((resolve, reject) => {
|
||||
promisedAPI(`api/addrs/${addr}/txs?from=0&to=1`).then(response => {
|
||||
promisedAPI(`api/addrs/${addr}/txs?from=0&to=${response.totalItems}0`)
|
||||
.then(response => resolve(response.items))
|
||||
.catch(error => reject(error));
|
||||
}).catch(error => reject(error))
|
||||
});
|
||||
}
|
||||
|
||||
/*Read flo Data from txs of given Address
|
||||
options can be used to filter data
|
||||
limit : maximum number of filtered data (default = 1000, negative = no limit)
|
||||
ignoreOld : ignore old txs (default = 0)
|
||||
sentOnly : filters only sent data
|
||||
receivedOnly: filters only received data
|
||||
pattern : filters data that with JSON pattern
|
||||
filter : custom filter funtion for floData (eg . filter: d => {return d[0] == '$'})
|
||||
tx : (boolean) resolve tx data or not (resolves an Array of Object with tx details)
|
||||
sender : flo-id(s) of sender
|
||||
receiver : flo-id(s) of receiver
|
||||
*/
|
||||
floBlockchainAPI.readData = function(addr, options = {}) {
|
||||
options.limit = options.limit || 0;
|
||||
options.ignoreOld = options.ignoreOld || 0;
|
||||
if (typeof options.sender === "string") options.sender = [options.sender];
|
||||
if (typeof options.receiver === "string") options.receiver = [options.receiver];
|
||||
return new Promise((resolve, reject) => {
|
||||
promisedAPI(`api/addrs/${addr}/txs?from=0&to=1`).then(response => {
|
||||
var newItems = response.totalItems - options.ignoreOld;
|
||||
promisedAPI(`api/addrs/${addr}/txs?from=0&to=${newItems*2}`).then(response => {
|
||||
if (options.limit <= 0)
|
||||
options.limit = response.items.length;
|
||||
var filteredData = [];
|
||||
let numToRead = response.totalItems - options.ignoreOld,
|
||||
unconfirmedCount = 0;
|
||||
for (let i = 0; i < numToRead && filteredData.length < options.limit; i++) {
|
||||
if (!response.items[i].confirmations) { //unconfirmed transactions
|
||||
unconfirmedCount++;
|
||||
if (numToRead < response.items[i].length)
|
||||
numToRead++;
|
||||
continue;
|
||||
}
|
||||
if (options.pattern) {
|
||||
try {
|
||||
let jsonContent = JSON.parse(response.items[i].floData);
|
||||
if (!Object.keys(jsonContent).includes(options.pattern))
|
||||
continue;
|
||||
} catch (error) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if (options.sentOnly) {
|
||||
let flag = false;
|
||||
for (let vin of response.items[i].vin)
|
||||
if (vin.addr === addr) {
|
||||
flag = true;
|
||||
break;
|
||||
}
|
||||
if (!flag) continue;
|
||||
}
|
||||
if (Array.isArray(options.sender)) {
|
||||
let flag = false;
|
||||
for (let vin of response.items[i].vin)
|
||||
if (options.sender.includes(vin.addr)) {
|
||||
flag = true;
|
||||
break;
|
||||
}
|
||||
if (!flag) continue;
|
||||
}
|
||||
if (options.receivedOnly) {
|
||||
let flag = false;
|
||||
for (let vout of response.items[i].vout)
|
||||
if (vout.scriptPubKey.addresses[0] === addr) {
|
||||
flag = true;
|
||||
break;
|
||||
}
|
||||
if (!flag) continue;
|
||||
}
|
||||
if (Array.isArray(options.receiver)) {
|
||||
let flag = false;
|
||||
for (let vout of response.items[i].vout)
|
||||
if (options.receiver.includes(vout.scriptPubKey.addresses[0])) {
|
||||
flag = true;
|
||||
break;
|
||||
}
|
||||
if (!flag) continue;
|
||||
}
|
||||
if (options.filter && !options.filter(response.items[i].floData))
|
||||
continue;
|
||||
|
||||
if (options.tx) {
|
||||
let d = {}
|
||||
d.txid = response.items[i].txid;
|
||||
d.time = response.items[i].time;
|
||||
d.blockheight = response.items[i].blockheight;
|
||||
d.data = response.items[i].floData;
|
||||
filteredData.push(d);
|
||||
} else
|
||||
filteredData.push(response.items[i].floData);
|
||||
}
|
||||
resolve({
|
||||
totalTxs: response.totalItems - unconfirmedCount,
|
||||
data: filteredData
|
||||
});
|
||||
}).catch(error => {
|
||||
reject(error);
|
||||
});
|
||||
}).catch(error => {
|
||||
reject(error);
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
})('object' === typeof module ? module.exports : window.floBlockchainAPI = {});
|
||||
920
scripts/floCloudAPI.js
Normal file
920
scripts/floCloudAPI.js
Normal file
@ -0,0 +1,920 @@
|
||||
(function(EXPORTS) { //floCloudAPI v2.2.0a
|
||||
/* FLO Cloud operations to send/request application data*/
|
||||
'use strict';
|
||||
const floCloudAPI = EXPORTS;
|
||||
|
||||
var kBucket;
|
||||
const K_Bucket = floCloudAPI.K_Bucket = function(masterID, nodeList) {
|
||||
|
||||
const decodeID = floID => {
|
||||
let k = bitjs.Base58.decode(floID);
|
||||
k.shift();
|
||||
k.splice(-4, 4);
|
||||
let decodedId = Crypto.util.bytesToHex(k);
|
||||
let nodeIdBigInt = new BigInteger(decodedId, 16);
|
||||
let nodeIdBytes = nodeIdBigInt.toByteArrayUnsigned();
|
||||
let nodeIdNewInt8Array = new Uint8Array(nodeIdBytes);
|
||||
return nodeIdNewInt8Array;
|
||||
};
|
||||
|
||||
const _KB = new BuildKBucket({
|
||||
localNodeId: decodeID(masterID)
|
||||
});
|
||||
nodeList.forEach(id => _KB.add({
|
||||
id: decodeID(id),
|
||||
floID: id
|
||||
}));
|
||||
|
||||
const _CO = nodeList.map(id => [_KB.distance(_KB.localNodeId, decodeID(id)), id])
|
||||
.sort((a, b) => a[0] - b[0])
|
||||
.map(a => a[1]);
|
||||
|
||||
const self = this;
|
||||
Object.defineProperty(self, 'tree', {
|
||||
get: () => _KB
|
||||
});
|
||||
Object.defineProperty(self, 'list', {
|
||||
get: () => Array.from(_CO)
|
||||
});
|
||||
|
||||
self.isNode = floID => _CO.includes(floID);
|
||||
self.innerNodes = function(id1, id2) {
|
||||
if (!_CO.includes(id1) || !_CO.includes(id2))
|
||||
throw Error('Given nodes are not supernode');
|
||||
let iNodes = []
|
||||
for (let i = _CO.indexOf(id1) + 1; _CO[i] != id2; i++) {
|
||||
if (i < _CO.length)
|
||||
iNodes.push(_CO[i])
|
||||
else i = -1
|
||||
}
|
||||
return iNodes
|
||||
}
|
||||
self.outterNodes = function(id1, id2) {
|
||||
if (!_CO.includes(id1) || !_CO.includes(id2))
|
||||
throw Error('Given nodes are not supernode');
|
||||
let oNodes = []
|
||||
for (let i = _CO.indexOf(id2) + 1; _CO[i] != id1; i++) {
|
||||
if (i < _CO.length)
|
||||
oNodes.push(_CO[i])
|
||||
else i = -1
|
||||
}
|
||||
return oNodes
|
||||
}
|
||||
self.prevNode = function(id, N = 1) {
|
||||
let n = N || _CO.length;
|
||||
if (!_CO.includes(id))
|
||||
throw Error('Given node is not supernode');
|
||||
let pNodes = []
|
||||
for (let i = 0, j = _CO.indexOf(id) - 1; i < n; j--) {
|
||||
if (j == _CO.indexOf(id))
|
||||
break;
|
||||
else if (j > -1)
|
||||
pNodes[i++] = _CO[j]
|
||||
else j = _CO.length
|
||||
}
|
||||
return (N == 1 ? pNodes[0] : pNodes)
|
||||
}
|
||||
self.nextNode = function(id, N = 1) {
|
||||
let n = N || _CO.length;
|
||||
if (!_CO.includes(id))
|
||||
throw Error('Given node is not supernode');
|
||||
if (!n) n = _CO.length;
|
||||
let nNodes = []
|
||||
for (let i = 0, j = _CO.indexOf(id) + 1; i < n; j++) {
|
||||
if (j == _CO.indexOf(id))
|
||||
break;
|
||||
else if (j < _CO.length)
|
||||
nNodes[i++] = _CO[j]
|
||||
else j = -1
|
||||
}
|
||||
return (N == 1 ? nNodes[0] : nNodes)
|
||||
}
|
||||
self.closestNode = function(id, N = 1) {
|
||||
let decodedId = decodeID(id);
|
||||
let n = N || _CO.length;
|
||||
let cNodes = _KB.closest(decodedId, n)
|
||||
.map(k => k.floID)
|
||||
return (N == 1 ? cNodes[0] : cNodes)
|
||||
}
|
||||
}
|
||||
|
||||
floCloudAPI.init = function startCloudProcess(SNStorageID = floGlobals.SNStorageID, nodeList = null) {
|
||||
return new Promise((resolve, reject) => {
|
||||
try {
|
||||
nodeList = nodeList || Object.keys(floGlobals.supernodes);
|
||||
kBucket = new K_Bucket(SNStorageID, nodeList);
|
||||
resolve('Cloud init successful');
|
||||
} catch (error) {
|
||||
reject(error);
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
Object.defineProperty(floCloudAPI, 'kBucket', {
|
||||
get: () => kBucket
|
||||
});
|
||||
|
||||
const _inactive = new Set();
|
||||
|
||||
function ws_connect(snID) {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (!(snID in floGlobals.supernodes))
|
||||
return reject(`${snID} is not a supernode`)
|
||||
if (_inactive.has(snID))
|
||||
return reject(`${snID} is not active`)
|
||||
var wsConn = new WebSocket("wss://" + floGlobals.supernodes[snID].uri + "/");
|
||||
wsConn.onopen = evt => resolve(wsConn);
|
||||
wsConn.onerror = evt => {
|
||||
_inactive.add(snID)
|
||||
reject(`${snID} is unavailable`)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
function ws_activeConnect(snID, reverse = false) {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (_inactive.size === kBucket.list.length)
|
||||
return reject('Cloud offline');
|
||||
if (!(snID in floGlobals.supernodes))
|
||||
snID = kBucket.closestNode(snID);
|
||||
ws_connect(snID)
|
||||
.then(node => resolve(node))
|
||||
.catch(error => {
|
||||
if (reverse)
|
||||
var nxtNode = kBucket.prevNode(snID);
|
||||
else
|
||||
var nxtNode = kBucket.nextNode(snID);
|
||||
ws_activeConnect(nxtNode, reverse)
|
||||
.then(node => resolve(node))
|
||||
.catch(error => reject(error))
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
function fetch_API(snID, data) {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (_inactive.has(snID))
|
||||
return reject(`${snID} is not active`);
|
||||
let fetcher, sn_url = "https://" + floGlobals.supernodes[snID].uri;
|
||||
if (typeof data === "string")
|
||||
fetcher = fetch(sn_url + "?" + data);
|
||||
else if (typeof data === "object" && data.method === "POST")
|
||||
fetcher = fetch(sn_url, data);
|
||||
fetcher.then(response => {
|
||||
if (response.ok || response.status === 400 || response.status === 500)
|
||||
resolve(response);
|
||||
else
|
||||
reject(response);
|
||||
}).catch(error => reject(error))
|
||||
})
|
||||
}
|
||||
|
||||
function fetch_ActiveAPI(snID, data, reverse = false) {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (_inactive.size === kBucket.list.length)
|
||||
return reject('Cloud offline');
|
||||
if (!(snID in floGlobals.supernodes))
|
||||
snID = kBucket.closestNode(snID);
|
||||
fetch_API(snID, data)
|
||||
.then(result => resolve(result))
|
||||
.catch(error => {
|
||||
_inactive.add(snID)
|
||||
if (reverse)
|
||||
var nxtNode = kBucket.prevNode(snID);
|
||||
else
|
||||
var nxtNode = kBucket.nextNode(snID);
|
||||
fetch_ActiveAPI(nxtNode, data, reverse)
|
||||
.then(result => resolve(result))
|
||||
.catch(error => reject(error));
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
function singleRequest(floID, data_obj, method = "POST") {
|
||||
return new Promise((resolve, reject) => {
|
||||
let data;
|
||||
if (method === "POST")
|
||||
data = {
|
||||
method: "POST",
|
||||
body: JSON.stringify(data_obj)
|
||||
};
|
||||
else
|
||||
data = new URLSearchParams(JSON.parse(JSON.stringify(data_obj))).toString();
|
||||
fetch_ActiveAPI(floID, data).then(response => {
|
||||
if (response.ok)
|
||||
response.json()
|
||||
.then(result => resolve(result))
|
||||
.catch(error => reject(error))
|
||||
else response.text()
|
||||
.then(result => reject(response.status + ": " + result)) //Error Message from Node
|
||||
.catch(error => reject(error))
|
||||
}).catch(error => reject(error))
|
||||
})
|
||||
}
|
||||
|
||||
const _liveRequest = {};
|
||||
|
||||
function liveRequest(floID, request, callback) {
|
||||
const filterData = typeof request.status !== 'undefined' ?
|
||||
data => {
|
||||
if (request.status)
|
||||
return data;
|
||||
else {
|
||||
let filtered = {};
|
||||
for (let i in data)
|
||||
if (request.trackList.includes(i))
|
||||
filtered[i] = data[i];
|
||||
return filtered;
|
||||
}
|
||||
} :
|
||||
data => {
|
||||
data = objectifier(data);
|
||||
let filtered = {},
|
||||
r = request;
|
||||
for (let v in data) {
|
||||
let d = data[v];
|
||||
if ((!r.atVectorClock || r.atVectorClock == v) &&
|
||||
(r.atVectorClock || !r.lowerVectorClock || r.lowerVectorClock <= v) &&
|
||||
(r.atVectorClock || !r.upperVectorClock || r.upperVectorClock >= v) &&
|
||||
(!r.afterTime || r.afterTime < d.log_time) &&
|
||||
r.application == d.application &&
|
||||
r.receiverID == d.receiverID &&
|
||||
(!r.comment || r.comment == d.comment) &&
|
||||
(!r.type || r.type == d.type) &&
|
||||
(!r.senderID || r.senderID.includes(d.senderID)))
|
||||
filtered[v] = data[v];
|
||||
}
|
||||
return filtered;
|
||||
};
|
||||
|
||||
return new Promise((resolve, reject) => {
|
||||
ws_activeConnect(floID).then(node => {
|
||||
let randID = floCrypto.randString(5);
|
||||
node.send(JSON.stringify(request));
|
||||
node.onmessage = (evt) => {
|
||||
let d = null,
|
||||
e = null;
|
||||
try {
|
||||
d = filterData(JSON.parse(evt.data));
|
||||
} catch (error) {
|
||||
e = evt.data
|
||||
} finally {
|
||||
callback(d, e)
|
||||
}
|
||||
}
|
||||
_liveRequest[randID] = node;
|
||||
_liveRequest[randID].request = request;
|
||||
resolve(randID);
|
||||
}).catch(error => reject(error));
|
||||
});
|
||||
}
|
||||
|
||||
Object.defineProperty(floCloudAPI, 'liveRequest', {
|
||||
get: () => _liveRequest
|
||||
});
|
||||
|
||||
Object.defineProperty(floCloudAPI, 'inactive', {
|
||||
get: () => _inactive
|
||||
});
|
||||
|
||||
const util = floCloudAPI.util = {};
|
||||
|
||||
const encodeMessage = util.encodeMessage = function(message) {
|
||||
return btoa(unescape(encodeURIComponent(JSON.stringify(message))))
|
||||
}
|
||||
|
||||
const decodeMessage = util.decodeMessage = function(message) {
|
||||
return JSON.parse(decodeURIComponent(escape(atob(message))))
|
||||
}
|
||||
|
||||
const filterKey = util.filterKey = function(type, options) {
|
||||
return type + (options.comment ? ':' + options.comment : '') +
|
||||
'|' + (options.group || options.receiverID || floGlobals.adminID) +
|
||||
'|' + (options.application || floGlobals.application);
|
||||
}
|
||||
|
||||
const lastCommit = {};
|
||||
Object.defineProperty(lastCommit, 'get', {
|
||||
value: objName => JSON.parse(lastCommit[objName])
|
||||
});
|
||||
Object.defineProperty(lastCommit, 'set', {
|
||||
value: objName => lastCommit[objName] = JSON.stringify(floGlobals.appObjects[objName])
|
||||
});
|
||||
|
||||
function updateObject(objectName, dataSet) {
|
||||
try {
|
||||
console.log(dataSet)
|
||||
let vcList = Object.keys(dataSet).sort();
|
||||
for (let vc of vcList) {
|
||||
if (vc < floGlobals.lastVC[objectName] || dataSet[vc].type !== objectName)
|
||||
continue;
|
||||
switch (dataSet[vc].comment) {
|
||||
case "RESET":
|
||||
if (dataSet[vc].message.reset)
|
||||
floGlobals.appObjects[objectName] = dataSet[vc].message.reset;
|
||||
break;
|
||||
case "UPDATE":
|
||||
if (dataSet[vc].message.diff)
|
||||
floGlobals.appObjects[objectName] = diff.merge(floGlobals.appObjects[objectName], dataSet[vc].message.diff);
|
||||
}
|
||||
floGlobals.lastVC[objectName] = vc;
|
||||
}
|
||||
lastCommit.set(objectName);
|
||||
compactIDB.writeData("appObjects", floGlobals.appObjects[objectName], objectName);
|
||||
compactIDB.writeData("lastVC", floGlobals.lastVC[objectName], objectName);
|
||||
} catch (error) {
|
||||
console.error(error)
|
||||
}
|
||||
}
|
||||
|
||||
function storeGeneral(fk, dataSet) {
|
||||
try {
|
||||
console.log(dataSet)
|
||||
if (typeof floGlobals.generalData[fk] !== "object")
|
||||
floGlobals.generalData[fk] = {}
|
||||
for (let vc in dataSet) {
|
||||
floGlobals.generalData[fk][vc] = dataSet[vc];
|
||||
if (dataSet[vc].log_time > floGlobals.lastVC[fk])
|
||||
floGlobals.lastVC[fk] = dataSet[vc].log_time;
|
||||
}
|
||||
compactIDB.writeData("lastVC", floGlobals.lastVC[fk], fk)
|
||||
compactIDB.writeData("generalData", floGlobals.generalData[fk], fk)
|
||||
} catch (error) {
|
||||
console.error(error)
|
||||
}
|
||||
}
|
||||
|
||||
function objectifier(data) {
|
||||
if (!Array.isArray(data))
|
||||
data = [data];
|
||||
return Object.fromEntries(data.map(d => {
|
||||
d.message = decodeMessage(d.message);
|
||||
return [d.vectorClock, d];
|
||||
}));
|
||||
}
|
||||
|
||||
//set status as online for myFloID
|
||||
floCloudAPI.setStatus = function(options = {}) {
|
||||
return new Promise((resolve, reject) => {
|
||||
let callback = options.callback instanceof Function ? options.callback : (d, e) => console.debug(d, e);
|
||||
var request = {
|
||||
floID: myFloID,
|
||||
application: options.application || floGlobals.application,
|
||||
time: Date.now(),
|
||||
status: true,
|
||||
pubKey: myPubKey
|
||||
}
|
||||
let hashcontent = ["time", "application", "floID"].map(d => request[d]).join("|");
|
||||
request.sign = floCrypto.signData(hashcontent, myPrivKey);
|
||||
liveRequest(options.refID || floGlobals.adminID, request, callback)
|
||||
.then(result => resolve(result))
|
||||
.catch(error => reject(error))
|
||||
})
|
||||
}
|
||||
|
||||
//request status of floID(s) in trackList
|
||||
floCloudAPI.requestStatus = function(trackList, options = {}) {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (!Array.isArray(trackList))
|
||||
trackList = [trackList];
|
||||
let callback = options.callback instanceof Function ? options.callback : (d, e) => console.debug(d, e);
|
||||
let request = {
|
||||
status: false,
|
||||
application: options.application || floGlobals.application,
|
||||
trackList: trackList
|
||||
}
|
||||
liveRequest(options.refID || floGlobals.adminID, request, callback)
|
||||
.then(result => resolve(result))
|
||||
.catch(error => reject(error))
|
||||
})
|
||||
}
|
||||
|
||||
//send any message to supernode cloud storage
|
||||
const sendApplicationData = floCloudAPI.sendApplicationData = function(message, type, options = {}) {
|
||||
return new Promise((resolve, reject) => {
|
||||
var data = {
|
||||
senderID: myFloID,
|
||||
receiverID: options.receiverID || floGlobals.adminID,
|
||||
pubKey: myPubKey,
|
||||
message: encodeMessage(message),
|
||||
time: Date.now(),
|
||||
application: options.application || floGlobals.application,
|
||||
type: type,
|
||||
comment: options.comment || ""
|
||||
}
|
||||
let hashcontent = ["receiverID", "time", "application", "type", "message", "comment"]
|
||||
.map(d => data[d]).join("|")
|
||||
data.sign = floCrypto.signData(hashcontent, myPrivKey);
|
||||
singleRequest(data.receiverID, data)
|
||||
.then(result => resolve(result))
|
||||
.catch(error => reject(error))
|
||||
})
|
||||
}
|
||||
|
||||
//request any data from supernode cloud
|
||||
const requestApplicationData = floCloudAPI.requestApplicationData = function(type, options = {}) {
|
||||
return new Promise((resolve, reject) => {
|
||||
var request = {
|
||||
receiverID: options.receiverID || floGlobals.adminID,
|
||||
senderID: options.senderID || undefined,
|
||||
application: options.application || floGlobals.application,
|
||||
type: type,
|
||||
comment: options.comment || undefined,
|
||||
lowerVectorClock: options.lowerVectorClock || undefined,
|
||||
upperVectorClock: options.upperVectorClock || undefined,
|
||||
atVectorClock: options.atVectorClock || undefined,
|
||||
afterTime: options.afterTime || undefined,
|
||||
mostRecent: options.mostRecent || undefined,
|
||||
}
|
||||
|
||||
if (options.callback instanceof Function) {
|
||||
liveRequest(request.receiverID, request, options.callback)
|
||||
.then(result => resolve(result))
|
||||
.catch(error => reject(error))
|
||||
} else {
|
||||
if (options.method === "POST")
|
||||
request = {
|
||||
time: Date.now(),
|
||||
request
|
||||
};
|
||||
singleRequest(request.receiverID, request, options.method || "GET")
|
||||
.then(data => resolve(data)).catch(error => reject(error))
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
//(NEEDS UPDATE) delete data from supernode cloud (received only)
|
||||
floCloudAPI.deleteApplicationData = function(vectorClocks, options = {}) {
|
||||
return new Promise((resolve, reject) => {
|
||||
var delreq = {
|
||||
requestorID: myFloID,
|
||||
pubKey: myPubKey,
|
||||
time: Date.now(),
|
||||
delete: (Array.isArray(vectorClocks) ? vectorClocks : [vectorClocks]),
|
||||
application: options.application || floGlobals.application
|
||||
}
|
||||
let hashcontent = ["time", "application", "delete"]
|
||||
.map(d => delreq[d]).join("|")
|
||||
delreq.sign = floCrypto.signData(hashcontent, myPrivKey)
|
||||
singleRequest(delreq.requestorID, delreq).then(result => {
|
||||
let success = [],
|
||||
failed = [];
|
||||
result.forEach(r => r.status === 'fulfilled' ?
|
||||
success.push(r.value) : failed.push(r.reason));
|
||||
resolve({
|
||||
success,
|
||||
failed
|
||||
})
|
||||
}).catch(error => reject(error))
|
||||
})
|
||||
}
|
||||
|
||||
//(NEEDS UPDATE) edit comment of data in supernode cloud (mutable comments only)
|
||||
floCloudAPI.editApplicationData = function(vectorClock, newComment, oldData, options = {}) {
|
||||
return new Promise((resolve, reject) => {
|
||||
let p0
|
||||
if (!oldData) {
|
||||
options.atVectorClock = vectorClock;
|
||||
options.callback = false;
|
||||
p0 = requestApplicationData(false, options)
|
||||
} else
|
||||
p0 = Promise.resolve({
|
||||
vectorClock: {
|
||||
...oldData
|
||||
}
|
||||
})
|
||||
p0.then(d => {
|
||||
if (d.senderID != myFloID)
|
||||
return reject("Invalid requestorID")
|
||||
else if (!d.comment.startsWith("EDIT:"))
|
||||
return reject("Data immutable")
|
||||
let data = {
|
||||
requestorID: myFloID,
|
||||
receiverID: d.receiverID,
|
||||
time: Date.now(),
|
||||
application: d.application,
|
||||
edit: {
|
||||
vectorClock: vectorClock,
|
||||
comment: newComment
|
||||
}
|
||||
}
|
||||
d.comment = data.edit.comment;
|
||||
let hashcontent = ["receiverID", "time", "application", "type", "message",
|
||||
"comment"
|
||||
]
|
||||
.map(x => d[x]).join("|")
|
||||
data.edit.sign = floCrypto.signData(hashcontent, myPrivKey)
|
||||
singleRequest(data.receiverID, data)
|
||||
.then(result => resolve("Data comment updated"))
|
||||
.catch(error => reject(error))
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
//tag data in supernode cloud (subAdmin access only)
|
||||
floCloudAPI.tagApplicationData = function(vectorClock, tag, options = {}) {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (!floGlobals.subAdmins.includes(myFloID))
|
||||
return reject("Only subAdmins can tag data")
|
||||
var request = {
|
||||
receiverID: options.receiverID || floGlobals.adminID,
|
||||
requestorID: myFloID,
|
||||
pubKey: myPubKey,
|
||||
time: Date.now(),
|
||||
vectorClock: vectorClock,
|
||||
tag: tag,
|
||||
}
|
||||
let hashcontent = ["time", "vectorClock", 'tag'].map(d => request[d]).join("|");
|
||||
request.sign = floCrypto.signData(hashcontent, myPrivKey);
|
||||
singleRequest(request.receiverID, request)
|
||||
.then(result => resolve(result))
|
||||
.catch(error => reject(error))
|
||||
})
|
||||
}
|
||||
|
||||
//note data in supernode cloud (receiver only or subAdmin allowed if receiver is adminID)
|
||||
floCloudAPI.noteApplicationData = function(vectorClock, note, options = {}) {
|
||||
return new Promise((resolve, reject) => {
|
||||
var request = {
|
||||
receiverID: options.receiverID || floGlobals.adminID,
|
||||
requestorID: myFloID,
|
||||
pubKey: myPubKey,
|
||||
time: Date.now(),
|
||||
vectorClock: vectorClock,
|
||||
note: note,
|
||||
}
|
||||
let hashcontent = ["time", "vectorClock", 'note'].map(d => request[d]).join("|");
|
||||
request.sign = floCrypto.signData(hashcontent, myPrivKey);
|
||||
singleRequest(request.receiverID, request)
|
||||
.then(result => resolve(result))
|
||||
.catch(error => reject(error))
|
||||
})
|
||||
}
|
||||
|
||||
//send general data
|
||||
floCloudAPI.sendGeneralData = function(message, type, options = {}) {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (options.encrypt) {
|
||||
let encryptionKey = options.encrypt === true ?
|
||||
floGlobals.settings.encryptionKey : options.encrypt
|
||||
message = floCrypto.encryptData(JSON.stringify(message), encryptionKey)
|
||||
}
|
||||
sendApplicationData(message, type, options)
|
||||
.then(result => resolve(result))
|
||||
.catch(error => reject(error))
|
||||
})
|
||||
}
|
||||
|
||||
//request general data
|
||||
floCloudAPI.requestGeneralData = function(type, options = {}) {
|
||||
return new Promise((resolve, reject) => {
|
||||
var fk = filterKey(type, options)
|
||||
floGlobals.lastVC[fk] = parseInt(floGlobals.lastVC[fk]) || 0;
|
||||
options.afterTime = options.afterTime || floGlobals.lastVC[fk];
|
||||
if (options.callback instanceof Function) {
|
||||
let new_options = Object.create(options)
|
||||
new_options.callback = (d, e) => {
|
||||
storeGeneral(fk, d);
|
||||
options.callback(d, e)
|
||||
}
|
||||
requestApplicationData(type, new_options)
|
||||
.then(result => resolve(result))
|
||||
.catch(error => reject(error))
|
||||
} else {
|
||||
requestApplicationData(type, options).then(dataSet => {
|
||||
storeGeneral(fk, objectifier(dataSet))
|
||||
resolve(dataSet)
|
||||
}).catch(error => reject(error))
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
//request an object data from supernode cloud
|
||||
floCloudAPI.requestObjectData = function(objectName, options = {}) {
|
||||
return new Promise((resolve, reject) => {
|
||||
options.lowerVectorClock = options.lowerVectorClock || floGlobals.lastVC[objectName] + 1;
|
||||
options.senderID = [false, null].includes(options.senderID) ? null :
|
||||
options.senderID || floGlobals.subAdmins;
|
||||
options.mostRecent = true;
|
||||
options.comment = 'RESET';
|
||||
let callback = null;
|
||||
if (options.callback instanceof Function) {
|
||||
let old_callback = options.callback;
|
||||
callback = (d, e) => {
|
||||
updateObject(objectName, d);
|
||||
old_callback(d, e);
|
||||
}
|
||||
delete options.callback;
|
||||
}
|
||||
requestApplicationData(objectName, options).then(dataSet => {
|
||||
updateObject(objectName, objectifier(dataSet));
|
||||
delete options.comment;
|
||||
options.lowerVectorClock = floGlobals.lastVC[objectName] + 1;
|
||||
delete options.mostRecent;
|
||||
if (callback) {
|
||||
let new_options = Object.create(options);
|
||||
new_options.callback = callback;
|
||||
requestApplicationData(objectName, new_options)
|
||||
.then(result => resolve(result))
|
||||
.catch(error => reject(error))
|
||||
} else {
|
||||
requestApplicationData(objectName, options).then(dataSet => {
|
||||
updateObject(objectName, objectifier(dataSet))
|
||||
resolve(floGlobals.appObjects[objectName])
|
||||
}).catch(error => reject(error))
|
||||
}
|
||||
}).catch(error => reject(error))
|
||||
})
|
||||
}
|
||||
|
||||
floCloudAPI.closeRequest = function(requestID) {
|
||||
return new Promise((resolve, reject) => {
|
||||
let conn = _liveRequest[requestID]
|
||||
if (!conn)
|
||||
return reject('Request not found')
|
||||
conn.onclose = evt => {
|
||||
delete _liveRequest[requestID];
|
||||
resolve('Request connection closed')
|
||||
}
|
||||
conn.close()
|
||||
})
|
||||
}
|
||||
|
||||
//reset or initialize an object and send it to cloud
|
||||
floCloudAPI.resetObjectData = function(objectName, options = {}) {
|
||||
return new Promise((resolve, reject) => {
|
||||
let message = {
|
||||
reset: floGlobals.appObjects[objectName]
|
||||
}
|
||||
options.comment = 'RESET';
|
||||
sendApplicationData(message, objectName, options).then(result => {
|
||||
lastCommit.set(objectName);
|
||||
resolve(result)
|
||||
}).catch(error => reject(error))
|
||||
})
|
||||
}
|
||||
|
||||
//update the diff and send it to cloud
|
||||
floCloudAPI.updateObjectData = function(objectName, options = {}) {
|
||||
return new Promise((resolve, reject) => {
|
||||
let message = {
|
||||
diff: diff.find(lastCommit.get(objectName), floGlobals.appObjects[
|
||||
objectName])
|
||||
}
|
||||
options.comment = 'UPDATE';
|
||||
sendApplicationData(message, objectName, options).then(result => {
|
||||
lastCommit.set(objectName);
|
||||
resolve(result)
|
||||
}).catch(error => reject(error))
|
||||
})
|
||||
}
|
||||
|
||||
/*
|
||||
Functions:
|
||||
findDiff(original, updatedObj) returns an object with the added, deleted and updated differences
|
||||
mergeDiff(original, allDiff) returns a new object from original object merged with all differences (allDiff is returned object of findDiff)
|
||||
*/
|
||||
var diff = (function() {
|
||||
const isDate = d => d instanceof Date;
|
||||
const isEmpty = o => Object.keys(o).length === 0;
|
||||
const isObject = o => o != null && typeof o === 'object';
|
||||
const properObject = o => isObject(o) && !o.hasOwnProperty ? {
|
||||
...o
|
||||
} : o;
|
||||
const getLargerArray = (l, r) => l.length > r.length ? l : r;
|
||||
|
||||
const preserve = (diff, left, right) => {
|
||||
if (!isObject(diff)) return diff;
|
||||
return Object.keys(diff).reduce((acc, key) => {
|
||||
const leftArray = left[key];
|
||||
const rightArray = right[key];
|
||||
if (Array.isArray(leftArray) && Array.isArray(rightArray)) {
|
||||
const array = [...getLargerArray(leftArray, rightArray)];
|
||||
return {
|
||||
...acc,
|
||||
[key]: array.reduce((acc2, item, index) => {
|
||||
if (diff[key].hasOwnProperty(index)) {
|
||||
acc2[index] = preserve(diff[key][index], leftArray[index], rightArray[index]); // diff recurse and check for nested arrays
|
||||
return acc2;
|
||||
}
|
||||
delete acc2[index]; // no diff aka empty
|
||||
return acc2;
|
||||
}, array)
|
||||
};
|
||||
}
|
||||
return {
|
||||
...acc,
|
||||
[key]: diff[key]
|
||||
};
|
||||
}, {});
|
||||
};
|
||||
|
||||
const updatedDiff = (lhs, rhs) => {
|
||||
if (lhs === rhs) return {};
|
||||
if (!isObject(lhs) || !isObject(rhs)) return rhs;
|
||||
const l = properObject(lhs);
|
||||
const r = properObject(rhs);
|
||||
if (isDate(l) || isDate(r)) {
|
||||
if (l.valueOf() == r.valueOf()) return {};
|
||||
return r;
|
||||
}
|
||||
return Object.keys(r).reduce((acc, key) => {
|
||||
if (l.hasOwnProperty(key)) {
|
||||
const difference = updatedDiff(l[key], r[key]);
|
||||
if (isObject(difference) && isEmpty(difference) && !isDate(difference)) return acc;
|
||||
return {
|
||||
...acc,
|
||||
[key]: difference
|
||||
};
|
||||
}
|
||||
return acc;
|
||||
}, {});
|
||||
};
|
||||
|
||||
|
||||
const diff = (lhs, rhs) => {
|
||||
if (lhs === rhs) return {}; // equal return no diff
|
||||
if (!isObject(lhs) || !isObject(rhs)) return rhs; // return updated rhs
|
||||
const l = properObject(lhs);
|
||||
const r = properObject(rhs);
|
||||
const deletedValues = Object.keys(l).reduce((acc, key) => {
|
||||
return r.hasOwnProperty(key) ? acc : {
|
||||
...acc,
|
||||
[key]: null
|
||||
};
|
||||
}, {});
|
||||
if (isDate(l) || isDate(r)) {
|
||||
if (l.valueOf() == r.valueOf()) return {};
|
||||
return r;
|
||||
}
|
||||
return Object.keys(r).reduce((acc, key) => {
|
||||
if (!l.hasOwnProperty(key)) return {
|
||||
...acc,
|
||||
[key]: r[key]
|
||||
}; // return added r key
|
||||
const difference = diff(l[key], r[key]);
|
||||
if (isObject(difference) && isEmpty(difference) && !isDate(difference)) return acc; // return no diff
|
||||
return {
|
||||
...acc,
|
||||
[key]: difference
|
||||
}; // return updated key
|
||||
}, deletedValues);
|
||||
};
|
||||
|
||||
const addedDiff = (lhs, rhs) => {
|
||||
if (lhs === rhs || !isObject(lhs) || !isObject(rhs)) return {};
|
||||
const l = properObject(lhs);
|
||||
const r = properObject(rhs);
|
||||
return Object.keys(r).reduce((acc, key) => {
|
||||
if (l.hasOwnProperty(key)) {
|
||||
const difference = addedDiff(l[key], r[key]);
|
||||
if (isObject(difference) && isEmpty(difference)) return acc;
|
||||
return {
|
||||
...acc,
|
||||
[key]: difference
|
||||
};
|
||||
}
|
||||
return {
|
||||
...acc,
|
||||
[key]: r[key]
|
||||
};
|
||||
}, {});
|
||||
};
|
||||
|
||||
const arrayDiff = (lhs, rhs) => {
|
||||
if (lhs === rhs) return {}; // equal return no diff
|
||||
if (!isObject(lhs) || !isObject(rhs)) return rhs; // return updated rhs
|
||||
const l = properObject(lhs);
|
||||
const r = properObject(rhs);
|
||||
const deletedValues = Object.keys(l).reduce((acc, key) => {
|
||||
return r.hasOwnProperty(key) ? acc : {
|
||||
...acc,
|
||||
[key]: null
|
||||
};
|
||||
}, {});
|
||||
if (isDate(l) || isDate(r)) {
|
||||
if (l.valueOf() == r.valueOf()) return {};
|
||||
return r;
|
||||
}
|
||||
if (Array.isArray(r) && Array.isArray(l)) {
|
||||
const deletedValues = l.reduce((acc, item, index) => {
|
||||
return r.hasOwnProperty(index) ? acc.concat(item) : acc.concat(null);
|
||||
}, []);
|
||||
return r.reduce((acc, rightItem, index) => {
|
||||
if (!deletedValues.hasOwnProperty(index)) {
|
||||
return acc.concat(rightItem);
|
||||
}
|
||||
const leftItem = l[index];
|
||||
const difference = diff(rightItem, leftItem);
|
||||
if (isObject(difference) && isEmpty(difference) && !isDate(difference)) {
|
||||
delete acc[index];
|
||||
return acc; // return no diff
|
||||
}
|
||||
return acc.slice(0, index).concat(rightItem).concat(acc.slice(index + 1)); // return updated key
|
||||
}, deletedValues);
|
||||
}
|
||||
|
||||
return Object.keys(r).reduce((acc, key) => {
|
||||
if (!l.hasOwnProperty(key)) return {
|
||||
...acc,
|
||||
[key]: r[key]
|
||||
}; // return added r key
|
||||
const difference = diff(l[key], r[key]);
|
||||
if (isObject(difference) && isEmpty(difference) && !isDate(difference)) return acc; // return no diff
|
||||
return {
|
||||
...acc,
|
||||
[key]: difference
|
||||
}; // return updated key
|
||||
}, deletedValues);
|
||||
};
|
||||
|
||||
const deletedDiff = (lhs, rhs) => {
|
||||
if (lhs === rhs || !isObject(lhs) || !isObject(rhs)) return {};
|
||||
const l = properObject(lhs);
|
||||
const r = properObject(rhs);
|
||||
return Object.keys(l).reduce((acc, key) => {
|
||||
if (r.hasOwnProperty(key)) {
|
||||
const difference = deletedDiff(l[key], r[key]);
|
||||
if (isObject(difference) && isEmpty(difference)) return acc;
|
||||
return {
|
||||
...acc,
|
||||
[key]: difference
|
||||
};
|
||||
}
|
||||
return {
|
||||
...acc,
|
||||
[key]: null
|
||||
};
|
||||
}, {});
|
||||
};
|
||||
|
||||
const mergeRecursive = (obj1, obj2) => {
|
||||
for (var p in obj2) {
|
||||
try {
|
||||
if (obj2[p].constructor == Object)
|
||||
obj1[p] = mergeRecursive(obj1[p], obj2[p]);
|
||||
// Property in destination object set; update its value.
|
||||
else if (Ext.isArray(obj2[p])) {
|
||||
// obj1[p] = [];
|
||||
if (obj2[p].length < 1)
|
||||
obj1[p] = obj2[p];
|
||||
else
|
||||
obj1[p] = mergeRecursive(obj1[p], obj2[p]);
|
||||
} else
|
||||
obj1[p] = obj2[p];
|
||||
} catch (e) {
|
||||
// Property in destination object not set; create it and set its value.
|
||||
obj1[p] = obj2[p];
|
||||
}
|
||||
}
|
||||
return obj1;
|
||||
}
|
||||
|
||||
const cleanse = (obj) => {
|
||||
Object.keys(obj).forEach(key => {
|
||||
var value = obj[key];
|
||||
if (typeof value === "object" && value !== null) {
|
||||
// Recurse...
|
||||
cleanse(value);
|
||||
// ...and remove if now "empty" (NOTE: insert your definition of "empty" here)
|
||||
//if (!Object.keys(value).length)
|
||||
// delete obj[key];
|
||||
} else if (value === null)
|
||||
delete obj[key]; // null, remove it
|
||||
});
|
||||
if (obj.constructor.toString().indexOf("Array") != -1) {
|
||||
obj = obj.filter(function(el) {
|
||||
return el != null;
|
||||
});
|
||||
}
|
||||
return obj;
|
||||
}
|
||||
|
||||
|
||||
const findDiff = (lhs, rhs) => ({
|
||||
added: addedDiff(lhs, rhs),
|
||||
deleted: deletedDiff(lhs, rhs),
|
||||
updated: updatedDiff(lhs, rhs),
|
||||
});
|
||||
|
||||
/*obj is original object or array, diff is the output of findDiff */
|
||||
const mergeDiff = (obj, diff) => {
|
||||
if (Object.keys(diff.updated).length !== 0)
|
||||
obj = mergeRecursive(obj, diff.updated)
|
||||
if (Object.keys(diff.deleted).length !== 0) {
|
||||
obj = mergeRecursive(obj, diff.deleted)
|
||||
obj = cleanse(obj)
|
||||
}
|
||||
if (Object.keys(diff.added).length !== 0)
|
||||
obj = mergeRecursive(obj, diff.added)
|
||||
return obj
|
||||
}
|
||||
|
||||
return {
|
||||
find: findDiff,
|
||||
merge: mergeDiff
|
||||
}
|
||||
})();
|
||||
|
||||
|
||||
})('object' === typeof module ? module.exports : window.floCloudAPI = {});
|
||||
313
scripts/floCrypto.js
Normal file
313
scripts/floCrypto.js
Normal file
@ -0,0 +1,313 @@
|
||||
(function(EXPORTS) { //floCrypto v2.3.0a
|
||||
/* 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"));
|
||||
|
||||
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(Math.random() * (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(Math.random() * 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);
|
||||
key.setCompressed(true);
|
||||
var privateKeyArr = key.getBitcoinPrivateKeyByteArray();
|
||||
var privateKey = BigInteger.fromByteArrayUnsigned(privateKeyArr);
|
||||
var messageHash = Crypto.SHA256(data);
|
||||
var messageHashBigInteger = new BigInteger(messageHash);
|
||||
var messageSign = Bitcoin.ECDSA.sign(messageHashBigInteger, 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 messageHashBigInteger = new BigInteger(msgHash);
|
||||
var sigBytes = Crypto.util.hexToBytes(signatureHex);
|
||||
var signature = Bitcoin.ECDSA.parseSig(sigBytes);
|
||||
var publicKeyPoint = ecparams.getCurve().decodePointHex(publicKeyHex);
|
||||
var verify = Bitcoin.ECDSA.verifyRaw(messageHashBigInteger, signature.r, signature.s, 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.defineProperty(floCrypto, 'newID', {
|
||||
get: () => generateNewID()
|
||||
});
|
||||
|
||||
//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;
|
||||
}
|
||||
}
|
||||
|
||||
//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 == key.getPubKeyHex())
|
||||
return true;
|
||||
else
|
||||
return false;
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
//Check if the given Address is valid or not
|
||||
floCrypto.validateFloID = floCrypto.validateAddr = function(inpAddr) {
|
||||
if (!inpAddr)
|
||||
return false;
|
||||
try {
|
||||
let addr = new Bitcoin.Address(inpAddr);
|
||||
return true;
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
//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 = {});
|
||||
603
scripts/floDapps.js
Normal file
603
scripts/floDapps.js
Normal file
@ -0,0 +1,603 @@
|
||||
(function(EXPORTS) { //floDapps v2.2.0
|
||||
/* General functions for FLO Dapps*/
|
||||
//'use strict';
|
||||
const floDapps = EXPORTS;
|
||||
|
||||
function initIndexedDB() {
|
||||
return new Promise((resolve, reject) => {
|
||||
var obs_g = {
|
||||
//general
|
||||
lastTx: {},
|
||||
//supernode (cloud list)
|
||||
supernodes: {
|
||||
indexes: {
|
||||
uri: null,
|
||||
pubKey: null
|
||||
}
|
||||
}
|
||||
}
|
||||
var obs_a = {
|
||||
//login credentials
|
||||
credentials: {},
|
||||
//for Dapps
|
||||
subAdmins: {},
|
||||
settings: {},
|
||||
appObjects: {},
|
||||
generalData: {},
|
||||
lastVC: {}
|
||||
}
|
||||
//add other given objectStores
|
||||
initIndexedDB.appObs = initIndexedDB.appObs || {}
|
||||
for (o in initIndexedDB.appObs)
|
||||
if (!(o in obs_a))
|
||||
obs_a[o] = initIndexedDB.appObs[o]
|
||||
Promise.all([
|
||||
compactIDB.initDB(floGlobals.application, obs_a),
|
||||
compactIDB.initDB("floDapps", obs_g)
|
||||
]).then(result => {
|
||||
compactIDB.setDefaultDB(floGlobals.application)
|
||||
resolve("IndexedDB App Storage Initated Successfully")
|
||||
}).catch(error => reject(error));
|
||||
})
|
||||
}
|
||||
|
||||
function initUserDB(floID) {
|
||||
return new Promise((resolve, reject) => {
|
||||
var obs = {
|
||||
contacts: {},
|
||||
pubKeys: {},
|
||||
messages: {}
|
||||
}
|
||||
compactIDB.initDB(`floDapps#${floID}`, obs).then(result => {
|
||||
resolve("UserDB Initated Successfully")
|
||||
}).catch(error => reject('Init userDB failed'));
|
||||
})
|
||||
}
|
||||
|
||||
function loadUserDB(floID) {
|
||||
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], `floDapps#${floID}`)
|
||||
Promise.all(promises).then(results => {
|
||||
for (var i = 0; i < loadData.length; i++)
|
||||
floGlobals[loadData[i]] = results[i]
|
||||
resolve("Loaded Data from userDB")
|
||||
}).catch(error => reject('Load userDB failed'))
|
||||
})
|
||||
}
|
||||
|
||||
const startUpFunctions = [];
|
||||
|
||||
startUpFunctions.push(function readSupernodeListFromAPI() {
|
||||
return new Promise((resolve, reject) => {
|
||||
compactIDB.readData("lastTx", floGlobals.SNStorageID, "floDapps").then(lastTx => {
|
||||
floBlockchainAPI.readData(floGlobals.SNStorageID, {
|
||||
ignoreOld: lastTx,
|
||||
sentOnly: true,
|
||||
pattern: "SuperNodeStorage"
|
||||
}).then(result => {
|
||||
for (var i = result.data.length - 1; i >= 0; i--) {
|
||||
var content = JSON.parse(result.data[i]).SuperNodeStorage;
|
||||
for (sn in content.removeNodes)
|
||||
compactIDB.removeData("supernodes", sn, "floDapps");
|
||||
for (sn in content.newNodes)
|
||||
compactIDB.writeData("supernodes", content.newNodes[sn], sn, "floDapps");
|
||||
}
|
||||
compactIDB.writeData("lastTx", result.totalTxs, floGlobals.SNStorageID, "floDapps");
|
||||
compactIDB.readAllData("supernodes", "floDapps").then(result => {
|
||||
floGlobals.supernodes = result;
|
||||
floCloudAPI.init()
|
||||
.then(result => resolve("Loaded Supernode list\n" + result))
|
||||
.catch(error => reject(error))
|
||||
})
|
||||
})
|
||||
}).catch(error => reject(error))
|
||||
})
|
||||
});
|
||||
|
||||
startUpFunctions.push(function readAppConfigFromAPI() {
|
||||
return new Promise((resolve, reject) => {
|
||||
compactIDB.readData("lastTx", `${floGlobals.application}|${floGlobals.adminID}`, "floDapps").then(lastTx => {
|
||||
floBlockchainAPI.readData(floGlobals.adminID, {
|
||||
ignoreOld: lastTx,
|
||||
sentOnly: true,
|
||||
pattern: floGlobals.application
|
||||
}).then(result => {
|
||||
for (var i = result.data.length - 1; i >= 0; i--) {
|
||||
var content = JSON.parse(result.data[i])[floGlobals.application];
|
||||
if (!content || typeof content !== "object")
|
||||
continue;
|
||||
if (Array.isArray(content.removeSubAdmin))
|
||||
for (var j = 0; j < content.removeSubAdmin.length; j++)
|
||||
compactIDB.removeData("subAdmins", content.removeSubAdmin[j]);
|
||||
if (Array.isArray(content.addSubAdmin))
|
||||
for (var k = 0; k < content.addSubAdmin.length; k++)
|
||||
compactIDB.writeData("subAdmins", true, content.addSubAdmin[k]);
|
||||
if (content.settings)
|
||||
for (let l in content.settings)
|
||||
compactIDB.writeData("settings", content.settings[l], l)
|
||||
}
|
||||
compactIDB.writeData("lastTx", result.totalTxs, `${floGlobals.application}|${floGlobals.adminID}`, "floDapps");
|
||||
compactIDB.readAllData("subAdmins").then(result => {
|
||||
floGlobals.subAdmins = Object.keys(result);
|
||||
compactIDB.readAllData("settings").then(result => {
|
||||
floGlobals.settings = result;
|
||||
resolve("Read app configuration from blockchain");
|
||||
})
|
||||
})
|
||||
})
|
||||
}).catch(error => reject(error))
|
||||
})
|
||||
});
|
||||
|
||||
startUpFunctions.push(function loadDataFromAppIDB() {
|
||||
return new Promise((resolve, reject) => {
|
||||
var loadData = ["appObjects", "generalData", "lastVC"]
|
||||
var promises = []
|
||||
for (var i = 0; i < loadData.length; i++)
|
||||
promises[i] = compactIDB.readAllData(loadData[i])
|
||||
Promise.all(promises).then(results => {
|
||||
for (var i = 0; i < loadData.length; i++)
|
||||
floGlobals[loadData[i]] = results[i]
|
||||
resolve("Loaded Data from app IDB")
|
||||
}).catch(error => reject(error))
|
||||
})
|
||||
});
|
||||
|
||||
function getCredentials() {
|
||||
|
||||
const inputFn = getCredentials.privKeyInput ||
|
||||
(type => new Promise((resolve, reject) => {
|
||||
let inputVal = prompt(`Enter ${type}: `)
|
||||
if (inputVal === null)
|
||||
reject(null)
|
||||
else
|
||||
resolve(inputVal)
|
||||
}));
|
||||
|
||||
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(`${floGlobals.application}#privKey`)
|
||||
if (indexArr) {
|
||||
readSharesFromIDB(JSON.parse(indexArr))
|
||||
.then(result => resolve(result))
|
||||
.catch(error => reject(error))
|
||||
} else {
|
||||
var privKey;
|
||||
inputFn("PRIVATE_KEY").then(result => {
|
||||
if (!result)
|
||||
return reject("Empty Private Key")
|
||||
var floID = floCrypto.getFloID(result)
|
||||
if (!floID || !floCrypto.validateAddr(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(`${floGlobals.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 {
|
||||
inputFn("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 {
|
||||
myPrivKey = privKey
|
||||
myPubKey = floCrypto.getPubKeyHex(myPrivKey)
|
||||
myFloID = floCrypto.getFloID(myPubKey)
|
||||
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(myFloID)).then(r => {
|
||||
callAndLog(loadUserDB(myFloID))
|
||||
.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 => 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 ? customFn = 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, `floDapps#${myFloID}`).then(result => {
|
||||
floGlobals.contacts[floID] = name;
|
||||
resolve("Contact stored")
|
||||
}).catch(error => reject(error))
|
||||
});
|
||||
}
|
||||
|
||||
floDapps.storePubKey = function(floID, pubKey) {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (floID in floGlobals.pubKeys)
|
||||
return resolve("pubKey already stored")
|
||||
if (!floCrypto.validateAddr(floID))
|
||||
return reject("Invalid floID!")
|
||||
if (floCrypto.getFloID(pubKey) != floID)
|
||||
return reject("Incorrect pubKey")
|
||||
compactIDB.writeData("pubKeys", pubKey, floID, `floDapps#${myFloID}`).then(result => {
|
||||
floGlobals.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: "floDapps",
|
||||
comment: floGlobals.application
|
||||
}
|
||||
if (floID in floGlobals.pubKeys)
|
||||
message = floCrypto.encryptData(JSON.stringify(message), floGlobals.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(floGlobals.messages).sort().pop()
|
||||
let options = {
|
||||
receiverID: myFloID,
|
||||
application: "floDapps",
|
||||
lowerVectorClock: lastVC + 1
|
||||
}
|
||||
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, myPrivKey)
|
||||
} catch (error) {}
|
||||
compactIDB.writeData("messages", d[v], v, `floDapps#${myFloID}`)
|
||||
floGlobals.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 (!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 = {
|
||||
[floGlobals.application]: {
|
||||
addSubAdmin: addList,
|
||||
removeSubAdmin: rmList,
|
||||
settings: settings
|
||||
}
|
||||
}
|
||||
var floID = floCrypto.getFloID(adminPrivKey)
|
||||
if (floID != floGlobals.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', floGlobals.application).then(result => {
|
||||
localStorage.removeItem(`${floGlobals.application}#privKey`)
|
||||
myPrivKey = myPubKey = myFloID = undefined;
|
||||
resolve("privKey credentials deleted!")
|
||||
}).catch(error => reject(error))
|
||||
})
|
||||
}
|
||||
|
||||
floDapps.deleteUserData = function(credentials = false) {
|
||||
return new Promise((resolve, reject) => {
|
||||
let p = []
|
||||
p.push(compactIDB.deleteDB(`floDapps#${myFloID}`))
|
||||
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(floGlobals.application).then(result => {
|
||||
localStorage.removeItem(`${floGlobals.application}#privKey`)
|
||||
myPrivKey = myPubKey = myFloID = undefined;
|
||||
compactIDB.removeData('lastTx', `${floGlobals.application}|${floGlobals.adminID}`, 'floDapps')
|
||||
.then(result => resolve("App database(local) deleted"))
|
||||
.catch(error => reject(error))
|
||||
}).catch(error => reject(error))
|
||||
})
|
||||
}
|
||||
|
||||
floDapps.securePrivKey = function(pwd) {
|
||||
return new Promise((resolve, reject) => {
|
||||
let indexArr = localStorage.getItem(`${floGlobals.application}#privKey`)
|
||||
if (!indexArr)
|
||||
return reject("PrivKey not found");
|
||||
indexArr = JSON.parse(indexArr)
|
||||
let encryptedKey = Crypto.AES.encrypt(myPrivKey, pwd);
|
||||
let threshold = indexArr.length;
|
||||
let shares = floCrypto.createShamirsSecretShares(encryptedKey, threshold, threshold)
|
||||
let promises = [];
|
||||
let overwriteFn = (share, index) =>
|
||||
compactIDB.writeData("credentials", share, index, floGlobals.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(`${floGlobals.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) ? myPrivKey : 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: floGlobals.contacts,
|
||||
pubKeys: floGlobals.pubKeys,
|
||||
messages: floGlobals.messages
|
||||
}
|
||||
let message = Crypto.AES.encrypt(JSON.stringify(sync), myPrivKey)
|
||||
let options = {
|
||||
receiverID: myFloID,
|
||||
application: "floDapps"
|
||||
}
|
||||
floCloudAPI.sendApplicationData(message, "syncData", options)
|
||||
.then(result => resolve(result))
|
||||
.catch(error => reject(error))
|
||||
});
|
||||
|
||||
syncData.newDevice = () => new Promise((resolve, reject) => {
|
||||
var options = {
|
||||
receiverID: myFloID,
|
||||
senderID: myFloID,
|
||||
application: "floDapps",
|
||||
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, myPrivKey))
|
||||
let promises = []
|
||||
let store = (key, val, obs) => promises.push(compactIDB.writeData(obs, val, key, `floDapps#${floID}`));
|
||||
["contacts", "pubKeys", "messages"].forEach(c => {
|
||||
for (let i in sync[c]) {
|
||||
store(i, sync[c][i], c)
|
||||
floGlobals[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 = {});
|
||||
6787
scripts/lib.js
Normal file
6787
scripts/lib.js
Normal file
File diff suppressed because it is too large
Load Diff
789
scripts/messenger.js
Normal file
789
scripts/messenger.js
Normal file
@ -0,0 +1,789 @@
|
||||
const messenger = {
|
||||
|
||||
util: {
|
||||
|
||||
sendRaw(message, recipient, type, encrypt = null, comment = undefined) {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (!floCrypto.validateAddr(recipient))
|
||||
return reject("Invalid Recipient floID");
|
||||
|
||||
if ([true, null].includes(encrypt) && recipient in floGlobals.pubKeys)
|
||||
message = floCrypto.encryptData(message, floGlobals.pubKeys[recipient])
|
||||
else if (encrypt === true)
|
||||
return reject("recipient's pubKey not found")
|
||||
let options = {
|
||||
receiverID: recipient,
|
||||
}
|
||||
if (comment)
|
||||
options.comment = comment
|
||||
floCloudAPI.sendApplicationData(message, type, options)
|
||||
.then(result => resolve(result))
|
||||
.catch(error => reject(error))
|
||||
})
|
||||
},
|
||||
|
||||
encrypt(value, key = floGlobals.appendix.AESKey) {
|
||||
return Crypto.AES.encrypt(value, key)
|
||||
},
|
||||
|
||||
decrypt(value, key = floGlobals.appendix.AESKey) {
|
||||
return Crypto.AES.decrypt(value, key)
|
||||
},
|
||||
|
||||
addMark(key, mark) {
|
||||
return new Promise((resolve, reject) => {
|
||||
compactIDB.readData("marked", key).then(result => {
|
||||
if (!result)
|
||||
result = [mark];
|
||||
else if (!result.includes(mark))
|
||||
result.push(mark);
|
||||
else
|
||||
return resolve("Mark already exist");
|
||||
compactIDB.writeData("marked", result, key)
|
||||
.then(result => resolve(result))
|
||||
.catch(error => reject(error))
|
||||
}).catch(error => reject(error))
|
||||
})
|
||||
},
|
||||
|
||||
removeMark(key, mark) {
|
||||
return new Promise((resolve, reject) => {
|
||||
compactIDB.readData("marked", key).then(result => {
|
||||
if (!result || !result.includes(mark))
|
||||
return resolve("Mark doesnot exist")
|
||||
else {
|
||||
result.splice(result.indexOf(mark),
|
||||
1); //remove the mark from the list of marks
|
||||
compactIDB.writeData("marked", result, key)
|
||||
.then(result => resolve("Mark removed"))
|
||||
.catch(error => reject(error))
|
||||
}
|
||||
}).catch(error => reject(error))
|
||||
})
|
||||
},
|
||||
|
||||
UIcallback: {
|
||||
group: (d, e) => console.log(d, e),
|
||||
direct: (d, e) => console.log(d, e)
|
||||
},
|
||||
|
||||
groupConn(groupID) {
|
||||
let utilFn = {
|
||||
encrypt: this.encrypt,
|
||||
decrypt: this.decrypt,
|
||||
UIcallback: this.UIcallback["group"],
|
||||
addMark: this.addMark
|
||||
}
|
||||
let callbackFn = function(dataSet, error) {
|
||||
if (error)
|
||||
return console.error(error)
|
||||
console.info(dataSet)
|
||||
let newInbox = {
|
||||
messages: {}
|
||||
}
|
||||
let infoChange = false;
|
||||
for (let vc in dataSet) {
|
||||
if (groupID !== dataSet[vc].receiverID ||
|
||||
!floGlobals.groups[groupID].members.includes(dataSet[vc].senderID))
|
||||
continue;
|
||||
try {
|
||||
let data = {
|
||||
time: dataSet[vc].time,
|
||||
sender: dataSet[vc].senderID,
|
||||
groupID: dataSet[vc].receiverID
|
||||
}
|
||||
let k = floGlobals.groups[groupID].eKey;
|
||||
if (floGlobals.expiredKeys[groupID]) {
|
||||
var ex = Object.keys(floGlobals.expiredKeys[groupID]).sort()
|
||||
while (ex.lenght && vc > ex[0]) ex.shift()
|
||||
if (ex.length)
|
||||
k = floGlobals.expiredKeys[groupID][ex.shift()]
|
||||
}
|
||||
dataSet[vc].message = utilFn.decrypt(dataSet[vc].message, k)
|
||||
//store the pubKey if not stored already
|
||||
floDapps.storePubKey(dataSet[vc].senderID, dataSet[vc].pubKey)
|
||||
if (dataSet[vc].type === "GROUP_MSG")
|
||||
data.message = utilFn.encrypt(dataSet[vc].message);
|
||||
else if (data.sender === floGlobals.groups[groupID].admin) {
|
||||
let groupInfo = floGlobals.groups[groupID]
|
||||
data.admin = true;
|
||||
if (dataSet[vc].type === "ADD_MEMBERS") {
|
||||
data.newMembers = dataSet[vc].message.split("|")
|
||||
data.note = dataSet[vc].comment
|
||||
groupInfo.members = [...new Set(groupInfo.members.concat(data
|
||||
.newMembers))]
|
||||
} else if (dataSet[vc].type === "RM_MEMBERS") {
|
||||
data.rmMembers = dataSet[vc].message.split("|")
|
||||
data.note = dataSet[vc].comment
|
||||
groupInfo.members = groupInfo.members.filter(m => !data.rmMembers
|
||||
.includes(m))
|
||||
if (data.rmMembers.includes(myFloID))
|
||||
groupInfo.status = false
|
||||
} else if (dataSet[vc].type === "UP_DESCRIPTION") {
|
||||
data.description = dataSet[vc].message
|
||||
groupInfo.description = data.description
|
||||
} else if (dataSet[vc].type === "UP_NAME") {
|
||||
data.name = dataSet[vc].message
|
||||
groupInfo.name = data.name
|
||||
}
|
||||
infoChange = true;
|
||||
}
|
||||
compactIDB.addData("messages", {
|
||||
...data
|
||||
}, `${groupID}|${vc}`)
|
||||
if (data.message)
|
||||
data.message = utilFn.decrypt(data.message);
|
||||
newInbox.messages[vc] = data;
|
||||
console.log(data)
|
||||
if (data.sender !== myFloID)
|
||||
utilFn.addMark(data.groupID, "unread")
|
||||
if (!floGlobals.appendix[`lastReceived_${groupID}`] ||
|
||||
floGlobals.appendix[`lastReceived_${groupID}`] < vc)
|
||||
floGlobals.appendix[`lastReceived_${groupID}`] = vc;
|
||||
} catch (error) {
|
||||
console.log(error)
|
||||
}
|
||||
}
|
||||
compactIDB.writeData("appendix", floGlobals.appendix[`lastReceived_${groupID}`],
|
||||
`lastReceived_${groupID}`);
|
||||
if (infoChange) {
|
||||
let newInfo = {
|
||||
...floGlobals.groups[groupID]
|
||||
}
|
||||
newInfo.eKey = utilFn.encrypt(newInfo.eKey)
|
||||
compactIDB.writeData("groups", newInfo, groupID)
|
||||
}
|
||||
utilFn.UIcallback(newInbox)
|
||||
}
|
||||
return floCloudAPI.requestApplicationData(null, {
|
||||
receiverID: groupID,
|
||||
lowerVectorClock: floGlobals.appendix[`lastReceived_${groupID}`] + 1,
|
||||
callback: callbackFn
|
||||
})
|
||||
}
|
||||
},
|
||||
|
||||
setUIcallbacks(directUI = null, groupUI = null) {
|
||||
if (directUI instanceof Function)
|
||||
this.util.UIcallback["direct"] = directUI
|
||||
if (groupUI instanceof Function)
|
||||
this.util.UIcallback["group"] = groupUI
|
||||
},
|
||||
|
||||
initUserDB() {
|
||||
return new Promise((resolve, reject) => {
|
||||
var obj = {
|
||||
messages: {},
|
||||
mails: {},
|
||||
marked: {},
|
||||
chats: {},
|
||||
groups: {},
|
||||
gkeys: {},
|
||||
appendix: {},
|
||||
userSettings: {}
|
||||
}
|
||||
compactIDB.initDB(`${floGlobals.application}_${myFloID}`, obj).then(result => {
|
||||
console.info(result)
|
||||
compactIDB.setDefaultDB(`${floGlobals.application}_${myFloID}`);
|
||||
resolve("Messenger UserDB Initated Successfully")
|
||||
}).catch(error => reject(error));
|
||||
})
|
||||
},
|
||||
|
||||
sendMessage(message, receiver) {
|
||||
return new Promise(async (resolve, reject) => {
|
||||
this.util.sendRaw(message, receiver, "MESSAGE").then(result => {
|
||||
let vc = Object.keys(result).pop()
|
||||
let data = {
|
||||
floID: receiver,
|
||||
time: result[vc].time,
|
||||
category: 'sent',
|
||||
message: this.util.encrypt(message)
|
||||
}
|
||||
floGlobals.chats[receiver] = parseInt(vc)
|
||||
compactIDB.writeData("chats", parseInt(vc), receiver)
|
||||
compactIDB.addData("messages", {
|
||||
...data
|
||||
}, `${receiver}|${vc}`)
|
||||
data.message = message;
|
||||
resolve({
|
||||
[vc]: data
|
||||
});
|
||||
}).catch(error => reject(error))
|
||||
})
|
||||
},
|
||||
|
||||
sendMail(subject, content, recipients, prev = null) {
|
||||
return new Promise(async (resolve, reject) => {
|
||||
if (!Array.isArray(recipients))
|
||||
recipients = [recipients]
|
||||
let mail = {
|
||||
subject: subject,
|
||||
content: content,
|
||||
ref: Date.now() + floCrypto.randString(8, true),
|
||||
prev: prev
|
||||
}
|
||||
let promises = recipients.map(r => this.util.sendRaw(JSON.stringify(mail), r, "MAIL"))
|
||||
Promise.allSettled(promises).then(results => {
|
||||
mail.time = Date.now();
|
||||
mail.from = myFloID
|
||||
mail.to = []
|
||||
results.forEach(r => {
|
||||
if (r.status === "fulfilled") {
|
||||
let vc = Object.keys(r.value).pop()
|
||||
mail.to.push(r.value[vc].receiverID)
|
||||
}
|
||||
})
|
||||
if (mail.to.length === 0)
|
||||
return reject(results)
|
||||
mail.content = this.util.encrypt(content)
|
||||
compactIDB.addData("mails", {
|
||||
...mail
|
||||
}, mail.ref)
|
||||
mail.content = content
|
||||
resolve({
|
||||
[mail.ref]: mail
|
||||
});
|
||||
})
|
||||
})
|
||||
},
|
||||
|
||||
requestDirectInbox() {
|
||||
return new Promise((resolve, reject) => {
|
||||
let utilFn = {
|
||||
encrypt: this.util.encrypt,
|
||||
decrypt: this.util.decrypt,
|
||||
UIcallback: this.util.UIcallback["direct"],
|
||||
groupConn: this.util.groupConn,
|
||||
addMark: this.util.addMark
|
||||
}
|
||||
let callbackFn = function(dataSet, error) {
|
||||
if (error)
|
||||
return console.error(error)
|
||||
let newInbox = {
|
||||
messages: {},
|
||||
mails: {},
|
||||
newgroups: [],
|
||||
keyrevoke: []
|
||||
}
|
||||
console.log(dataSet)
|
||||
for (let vc in dataSet) {
|
||||
try {
|
||||
//store the pubKey if not stored already
|
||||
floDapps.storePubKey(dataSet[vc].senderID, dataSet[vc].pubKey)
|
||||
if (dataSet[vc].message instanceof Object && "secret" in dataSet[vc].message)
|
||||
dataSet[vc].message = floCrypto.decryptData(dataSet[vc].message, myPrivKey)
|
||||
if (dataSet[vc].type === "MESSAGE") {
|
||||
//process as message
|
||||
let dm = {
|
||||
time: dataSet[vc].time,
|
||||
floID: dataSet[vc].senderID,
|
||||
category: "received",
|
||||
message: utilFn.encrypt(dataSet[vc].message)
|
||||
}
|
||||
compactIDB.addData("messages", {
|
||||
...dm
|
||||
}, `${dm.floID}|${vc}`)
|
||||
floGlobals.chats[dm.floID] = parseInt(vc)
|
||||
compactIDB.writeData("chats", parseInt(vc), dm.floID)
|
||||
dm.message = dataSet[vc].message;
|
||||
newInbox.messages[vc] = dm;
|
||||
utilFn.addMark(dm.floID, "unread")
|
||||
} else if (dataSet[vc].type === "MAIL") {
|
||||
//process as mail
|
||||
let data = JSON.parse(dataSet[vc].message);
|
||||
let mail = {
|
||||
time: dataSet[vc].time,
|
||||
from: dataSet[vc].senderID,
|
||||
to: [myFloID],
|
||||
subject: data.subject,
|
||||
content: utilFn.encrypt(data.content),
|
||||
ref: data.ref,
|
||||
prev: data.prev
|
||||
}
|
||||
compactIDB.addData("mails", {
|
||||
...mail
|
||||
}, mail.ref);
|
||||
mail.content = data.content;
|
||||
newInbox.mails[mail.ref] = mail;
|
||||
utilFn.addMark(mail.ref, "unread")
|
||||
} else if (dataSet[vc].type === "CREATE_GROUP") {
|
||||
//process create group
|
||||
let groupInfo = JSON.parse(dataSet[vc].message);
|
||||
let h = ["groupID", "created", "admin"].map(x => groupInfo[x]).join('|')
|
||||
if (groupInfo.admin === dataSet[vc].senderID &&
|
||||
floCrypto.verifySign(h, groupInfo.hash, groupInfo.pubKey) &&
|
||||
floCrypto.getFloID(groupInfo.pubKey) === groupInfo.groupID) {
|
||||
let eKey = groupInfo.eKey
|
||||
groupInfo.eKey = utilFn.encrypt(eKey)
|
||||
compactIDB.writeData("groups", {
|
||||
...groupInfo
|
||||
}, groupInfo.groupID)
|
||||
groupInfo.eKey = eKey
|
||||
floGlobals.groups[groupInfo.groupID] = groupInfo
|
||||
utilFn.groupConn(groupInfo.groupID)
|
||||
newInbox.newgroups.push(groupInfo.groupID)
|
||||
}
|
||||
} else if (dataSet[vc].type === "REVOKE_KEY") {
|
||||
let r = JSON.parse(dataSet[vc].message);
|
||||
let groupInfo = floGlobals.groups[r.groupID]
|
||||
if (dataSet[vc].senderID === groupInfo.admin) {
|
||||
if (typeof floGlobals.expiredKeys[r.groupID] !== "object")
|
||||
floGlobals.expiredKeys[r.groupID] = {}
|
||||
floGlobals.expiredKeys[r.groupID][vc] = groupInfo.eKey
|
||||
let eKey = r.newKey
|
||||
groupInfo.eKey = utilFn.encrypt(eKey);
|
||||
compactIDB.writeData("groups", {
|
||||
...groupInfo
|
||||
}, groupInfo.groupID)
|
||||
groupInfo.eKey = eKey
|
||||
newInbox.keyrevoke.push(groupInfo.groupID)
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
console.log(error)
|
||||
} finally {
|
||||
if (floGlobals.appendix.lastReceived < vc)
|
||||
floGlobals.appendix.lastReceived = vc;
|
||||
}
|
||||
}
|
||||
compactIDB.writeData("appendix", floGlobals.appendix.lastReceived, "lastReceived");
|
||||
utilFn.UIcallback(newInbox)
|
||||
}
|
||||
|
||||
var options = {
|
||||
receiverID: myFloID,
|
||||
lowerVectorClock: floGlobals.appendix.lastReceived + 1,
|
||||
callback: callbackFn
|
||||
}
|
||||
floCloudAPI.requestApplicationData(null, options)
|
||||
.then(result => resolve(result))
|
||||
.catch(error => reject(error))
|
||||
})
|
||||
},
|
||||
|
||||
getMail(mailRef) {
|
||||
return new Promise((resolve, reject) => {
|
||||
compactIDB.readData("mails", mailRef).then(mail => {
|
||||
mail.content = this.util.decrypt(mail.content)
|
||||
resolve(mail)
|
||||
}).catch(error => reject(error))
|
||||
});
|
||||
},
|
||||
|
||||
getChatOrder(type = ["direct", "group", "mixed"]) {
|
||||
if (typeof type === "string")
|
||||
type = type.split('|')
|
||||
let result = {}
|
||||
if (type.includes("direct"))
|
||||
result.direct = Object.keys(floGlobals.chats).map(a => [floGlobals.chats[a], a])
|
||||
.sort((a, b) => b[0] - a[0]).map(a => a[1])
|
||||
if (type.includes("group"))
|
||||
result.group = Object.keys(floGlobals.groups).map(a => [parseInt(floGlobals.appendix[`lastReceived_${a}`]), a])
|
||||
.sort((a, b) => b[0] - a[0]).map(a => a[1])
|
||||
if (type.includes("mixed"))
|
||||
result.mixed = Object.keys(floGlobals.chats).map(a => [floGlobals.chats[a], a])
|
||||
.concat(Object.keys(floGlobals.groups).map(a => [parseInt(floGlobals.appendix[`lastReceived_${a}`]), a]))
|
||||
.sort((a, b) => b[0] - a[0]).map(a => a[1])
|
||||
if (type.length === 1)
|
||||
result = result[type[0]]
|
||||
return result
|
||||
},
|
||||
|
||||
storeContact(floID, name) {
|
||||
return floDapps.storeContact(floID, name)
|
||||
},
|
||||
|
||||
loadDataFromIDB(dataList = 'default') {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (dataList === 'default')
|
||||
dataList = ["mails", "marked", "groups", "chats", "appendix"]
|
||||
else if (dataList === 'all')
|
||||
dataList = ["messages", "mails", "marked", "chats", "groups", "gkeys", "appendix"]
|
||||
let promises = []
|
||||
for (var i = 0; i < dataList.length; i++)
|
||||
promises[i] = compactIDB.readAllData(dataList[i])
|
||||
Promise.all(promises).then(results => {
|
||||
let data = {}
|
||||
for (var i = 0; i < dataList.length; i++)
|
||||
data[dataList[i]] = results[i]
|
||||
data.appendix.lastReceived = data.appendix.lastReceived || '0'
|
||||
if (data.appendix.AESKey) {
|
||||
try {
|
||||
let AESKey = floCrypto.decryptData(data.appendix.AESKey, myPrivKey);
|
||||
data.appendix.AESKey = AESKey;
|
||||
if (dataList.includes("messages"))
|
||||
for (let m in data.messages)
|
||||
if (data.messages[m].message)
|
||||
data.messages[m].message = this.util.decrypt(data.messages[m].message, AESKey)
|
||||
if (dataList.includes("mails"))
|
||||
for (let m in data.mails)
|
||||
data.mails[m].content = this.util.decrypt(data.mails[m].content, AESKey)
|
||||
if (dataList.includes("groups"))
|
||||
for (let g in data.groups)
|
||||
data.groups[g].eKey = this.util.decrypt(data.groups[g].eKey, AESKey)
|
||||
if (dataList.includes("gkeys"))
|
||||
for (let k in data.gkeys)
|
||||
data.gkeys[k] = this.util.decrypt(data.gkeys[k], AESKey)
|
||||
resolve(data)
|
||||
} catch (error) {
|
||||
reject("Corrupted AES Key");
|
||||
}
|
||||
} else {
|
||||
if (Object.keys(data.mails).length)
|
||||
return reject("AES Key not Found")
|
||||
let AESKey = floCrypto.randString(32);
|
||||
let encryptedKey = floCrypto.encryptData(AESKey, myPubKey);
|
||||
compactIDB.addData("appendix", encryptedKey, "AESKey").then(result => {
|
||||
data.appendix.AESKey = AESKey;
|
||||
resolve(data);
|
||||
}).catch(error => reject("Unable to Generate AES Key"))
|
||||
}
|
||||
}).catch(error => reject(error))
|
||||
})
|
||||
},
|
||||
|
||||
addMark(key, mark) {
|
||||
if (floGlobals.marked.hasOwnProperty(key) && !floGlobals.marked[key].includes(mark))
|
||||
floGlobals.marked[key].push(mark)
|
||||
return this.util.addMark(key, mark)
|
||||
},
|
||||
|
||||
removeMark(key, mark) {
|
||||
if (floGlobals.marked.hasOwnProperty(key))
|
||||
floGlobals.marked[key] = floGlobals.marked[key].filter(v => v !== mark)
|
||||
return this.util.removeMark(key, mark)
|
||||
},
|
||||
|
||||
addChat(chatID) {
|
||||
return new Promise((resolve, reject) => {
|
||||
compactIDB.addData("chats", 0, chatID)
|
||||
.then(result => resolve("Added chat"))
|
||||
.catch(error => reject(error))
|
||||
})
|
||||
},
|
||||
|
||||
rmChat(chatID) {
|
||||
return new Promise((resolve, reject) => {
|
||||
compactIDB.removeData("chats", chatID)
|
||||
.then(result => resolve("Chat removed"))
|
||||
.catch(error => reject(error))
|
||||
})
|
||||
},
|
||||
|
||||
clearChat(chatID) {
|
||||
return new Promise((resolve, reject) => {
|
||||
let options = {
|
||||
lowerKey: `${chatID}|`,
|
||||
upperKey: `${chatID}||`
|
||||
}
|
||||
compactIDB.searchData("messages", options).then(result => {
|
||||
let promises = []
|
||||
for (let i in result)
|
||||
promises.push(compactIDB.removeData("messages", i))
|
||||
Promise.all(promises)
|
||||
.then(result => resolve("Chat cleared"))
|
||||
.catch(error => reject(error))
|
||||
}).catch(error => reject(error))
|
||||
})
|
||||
},
|
||||
|
||||
getChat(chatID) {
|
||||
return new Promise((resolve, reject) => {
|
||||
let options = {
|
||||
lowerKey: `${chatID}|`,
|
||||
upperKey: `${chatID}||`
|
||||
}
|
||||
compactIDB.searchData("messages", options).then(result => {
|
||||
for (let i in result)
|
||||
if (result[i].message)
|
||||
result[i].message = this.util.decrypt(result[i].message)
|
||||
resolve(result)
|
||||
}).catch(error => reject(error))
|
||||
})
|
||||
},
|
||||
|
||||
backupData() {
|
||||
return new Promise((resolve, reject) => {
|
||||
this.loadDataFromIDB("all").then(data => {
|
||||
delete data.appendix.AESKey;
|
||||
data.contacts = floGlobals.contacts;
|
||||
data.pubKeys = floGlobals.pubKeys;
|
||||
data = btoa(unescape(encodeURIComponent(JSON.stringify(data))))
|
||||
let blobData = {
|
||||
floID: myFloID,
|
||||
pubKey: myPubKey,
|
||||
data: this.util.encrypt(data, myPrivKey),
|
||||
}
|
||||
blobData.sign = floCrypto.signData(blobData.data, myPrivKey);
|
||||
resolve(new Blob([JSON.stringify(blobData)], {
|
||||
type: 'application/json'
|
||||
}));
|
||||
}).catch(error => reject(error))
|
||||
})
|
||||
},
|
||||
|
||||
parseBackup(blob) {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (blob instanceof Blob || blob instanceof File) {
|
||||
let reader = new FileReader();
|
||||
reader.onload = evt => {
|
||||
var blobData = JSON.parse(evt.target.result);
|
||||
if (!floCrypto.verifySign(blobData.data, blobData.sign, blobData.pubKey))
|
||||
reject("Corrupted Backup file: Signature verification failed");
|
||||
else if (myFloID !== blobData.floID || myPubKey !== blobData.pubKey)
|
||||
reject("Invalid Backup file: Incorrect floID");
|
||||
else {
|
||||
try {
|
||||
let data = this.util.decrypt(blobData.data, myPrivKey)
|
||||
try {
|
||||
data = JSON.parse(decodeURIComponent(escape(atob(data))));
|
||||
resolve(data)
|
||||
} catch (e) {
|
||||
reject("Corrupted Backup file: Parse failed");
|
||||
}
|
||||
} catch (e) {
|
||||
reject("Corrupted Backup file: Decryption failed");
|
||||
}
|
||||
}
|
||||
}
|
||||
reader.readAsText(blob);
|
||||
} else
|
||||
reject("Backup is not a valid File (or) Blob")
|
||||
})
|
||||
},
|
||||
|
||||
restoreData(arg) {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (arg instanceof Blob || arg instanceof File)
|
||||
var parseData = this.parseBackup
|
||||
else
|
||||
var parseData = data => new Promise((res, rej) => res(data))
|
||||
parseData(arg).then(data => {
|
||||
for (let m in data.messages)
|
||||
if (data.messages[m].message)
|
||||
data.messages[m].message = this.util.encrypt(data.messages[m].message)
|
||||
for (let m in data.mail)
|
||||
data.mails[m].content = this.util.encrypt(data.mails[m].content)
|
||||
for (let k in data.gkeys)
|
||||
data.gkeys[k] = this.util.encrypt(data.gkeys[k])
|
||||
for (let g in data.groups)
|
||||
data.groups[g].eKey = this.util.encrypt(data.groups[g].eKey)
|
||||
for (let c in data.chats)
|
||||
if (data.chats[c] <= floGlobals.chats[c])
|
||||
delete data.chats[c]
|
||||
for (let l in data.appendix)
|
||||
if (l.startsWith('lastReceived') && data.appendix[l] <= floGlobals.appendix[l])
|
||||
delete data.appendix[l]
|
||||
for (let c in data.contacts)
|
||||
if (c in floGlobals.contacts)
|
||||
delete data.contact[c]
|
||||
for (let p in data.pubKeys)
|
||||
if (p in floGlobals.pubKeys)
|
||||
delete data.pubKeys[p]
|
||||
let promises = [];
|
||||
for (let obs in data) {
|
||||
let writeFn;
|
||||
switch (obs) {
|
||||
case "contacts":
|
||||
writeFn = (k, v) => floDapps.storeContact(k, v);
|
||||
break;
|
||||
case "pubKeys":
|
||||
writeFn = (k, v) => floDapps.storePubKey(k, v);
|
||||
break;
|
||||
default:
|
||||
writeFn = (k, v) => compactIDB.writeData(obs, v, k);
|
||||
break;
|
||||
}
|
||||
for (let k in data[obs])
|
||||
promises.push(writeFn(k, data[obs][k]));
|
||||
}
|
||||
|
||||
Promise.all(promises)
|
||||
.then(results => resolve("Restore Successful"))
|
||||
.catch(error => reject("Restore Failed: Unable to write to IDB"))
|
||||
}).catch(error => reject(error))
|
||||
})
|
||||
},
|
||||
|
||||
clearUserData() {
|
||||
return new Promise((resolve, reject) => {
|
||||
let promises = [
|
||||
compactIDB.deleteDB(),
|
||||
floDapps.clearCredentials()
|
||||
]
|
||||
Promise.all(promises)
|
||||
.then(result => resolve("User Data cleared"))
|
||||
.catch(error => reject(error))
|
||||
})
|
||||
},
|
||||
|
||||
//group feature
|
||||
|
||||
createGroup(groupname, description = '') {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (!groupname) return reject("Invalid Group Name")
|
||||
let id = floCrypto.generateNewID();
|
||||
let groupInfo = {
|
||||
groupID: id.floID,
|
||||
pubKey: id.pubKey,
|
||||
admin: myFloID,
|
||||
name: groupname,
|
||||
description: description,
|
||||
created: Date.now(),
|
||||
members: [myFloID]
|
||||
}
|
||||
let h = ["groupID", "created", "admin"].map(x => groupInfo[x]).join('|')
|
||||
groupInfo.hash = floCrypto.signData(h, id.privKey)
|
||||
let eKey = floCrypto.randString(16, false)
|
||||
groupInfo.eKey = this.util.encrypt(eKey)
|
||||
p1 = compactIDB.addData("groups", groupInfo, id.floID)
|
||||
p2 = compactIDB.addData("gkeys", this.util.encrypt(id.privKey), id.floID)
|
||||
Promise.all([p1, p2]).then(r => {
|
||||
groupInfo.eKey = eKey
|
||||
floGlobals.groups[id.floID] = groupInfo;
|
||||
this.util.groupConn(id.floID)
|
||||
resolve(groupInfo)
|
||||
}).catch(e => reject(e))
|
||||
})
|
||||
},
|
||||
|
||||
changeGroupName(groupID, name) {
|
||||
return new Promise((resolve, reject) => {
|
||||
let groupInfo = floGlobals.groups[groupID]
|
||||
if (myFloID !== groupInfo.admin)
|
||||
return reject("Access denied: Admin only!")
|
||||
let message = this.util.encrypt(name, groupInfo.eKey)
|
||||
this.util.sendRaw(message, groupID, "UP_NAME", false)
|
||||
.then(result => resolve('Name updated'))
|
||||
.catch(error => reject(error))
|
||||
})
|
||||
},
|
||||
|
||||
changeGroupDescription(groupID, description) {
|
||||
return new Promise((resolve, reject) => {
|
||||
let groupInfo = floGlobals.groups[groupID]
|
||||
if (myFloID !== groupInfo.admin)
|
||||
return reject("Access denied: Admin only!")
|
||||
let message = this.util.encrypt(description, groupInfo.eKey)
|
||||
this.util.sendRaw(message, groupID, "UP_DESCRIPTION", false)
|
||||
.then(result => resolve('Description updated'))
|
||||
.catch(error => reject(error))
|
||||
})
|
||||
},
|
||||
|
||||
addGroupMembers(groupID, newMem, note = undefined) {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (!Array.isArray(newMem) && typeof newMem === "string")
|
||||
newMem = [newMem]
|
||||
//check for validity
|
||||
let imem1 = [],
|
||||
imem2 = []
|
||||
newMem.forEach(m =>
|
||||
!floCrypto.validateAddr(m) ? imem1.push(m) :
|
||||
m in floGlobals.pubKeys ? null : imem2.push(m)
|
||||
);
|
||||
if (imem1.length)
|
||||
return reject(`Invalid Members(floIDs): ${imem1}`)
|
||||
else if (imem2.length)
|
||||
return reject(`Invalid Members (pubKey not available): ${imem2}`)
|
||||
//send new newMem list to existing members
|
||||
let groupInfo = floGlobals.groups[groupID]
|
||||
if (myFloID !== groupInfo.admin)
|
||||
return reject("Access denied: Admin only!")
|
||||
//send groupInfo to new newMem
|
||||
let k = groupInfo.eKey
|
||||
groupInfo = JSON.stringify(groupInfo)
|
||||
let promises = newMem.map(m => this.util.sendRaw(groupInfo, m, "CREATE_GROUP", true))
|
||||
Promise.allSettled(promises).then(results => {
|
||||
let success = [],
|
||||
failed = [];
|
||||
for (let i in results)
|
||||
if (results[i].status === "fulfilled")
|
||||
success.push(newMem[i])
|
||||
else if (results[i].status === "rejected")
|
||||
failed.push(newMem[i])
|
||||
console.log(success.join("|"), k)
|
||||
let message = this.util.encrypt(success.join("|"), k)
|
||||
this.util.sendRaw(message, groupID, "ADD_MEMBERS", false, note)
|
||||
.then(r => resolve(`Members added: ${success}`))
|
||||
.catch(e => reject(e))
|
||||
})
|
||||
})
|
||||
},
|
||||
|
||||
rmGroupMembers(groupID, rmMem, note = undefined) {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (!Array.isArray(rmMem) && typeof rmMem === "string")
|
||||
rmMem = [rmMem]
|
||||
let groupInfo = floGlobals.groups[groupID]
|
||||
let imem = rmMem.filter(m => !groupInfo.members.includes(m))
|
||||
if (imem.length)
|
||||
return reject(`Invalid members: ${imem}`)
|
||||
if (myFloID !== groupInfo.admin)
|
||||
return reject("Access denied: Admin only!")
|
||||
let message = this.util.encrypt(rmMem.join("|"), groupInfo.eKey)
|
||||
p1 = this.util.sendRaw(message, groupID, "RM_MEMBERS", false, note)
|
||||
groupInfo.members = groupInfo.members.filter(m => !rmMem.includes(m))
|
||||
p2 = this.revokeKey(groupID)
|
||||
Promise.all([p1, p2])
|
||||
.then(r => resolve(`Members removed: ${rmMem}`))
|
||||
.catch(e => reject(e))
|
||||
})
|
||||
},
|
||||
|
||||
revokeKey(groupID) {
|
||||
return new Promise((resolve, reject) => {
|
||||
let groupInfo = floGlobals.groups[groupID]
|
||||
if (myFloID !== groupInfo.admin)
|
||||
return reject("Access denied: Admin only!")
|
||||
let newKey = floCrypto.randString(16, false);
|
||||
Promise.all(groupInfo.members.map(m => this.util.sendRaw(JSON.stringify({
|
||||
newKey,
|
||||
groupID
|
||||
}), m, "REVOKE_KEY", true))).then(result => {
|
||||
resolve("Group key revoked")
|
||||
}).catch(error => reject(error))
|
||||
})
|
||||
},
|
||||
|
||||
sendGroupMessage(message, groupID) {
|
||||
return new Promise(async (resolve, reject) => {
|
||||
let k = floGlobals.groups[groupID].eKey
|
||||
message = this.util.encrypt(message, k)
|
||||
this.util.sendRaw(message, groupID, "GROUP_MSG", false)
|
||||
.then(result => resolve(`${groupID}: ${message}`))
|
||||
.catch(error => reject(error))
|
||||
})
|
||||
},
|
||||
|
||||
requestGroupInbox() {
|
||||
return new Promise((resolve) => {
|
||||
let promises = []
|
||||
let reqFn = (g) => new Promise((res, rej) => {
|
||||
this.util.groupConn(g)
|
||||
.then(r => res([g, r]))
|
||||
.catch(e => rej([g, e]))
|
||||
})
|
||||
for (let g in floGlobals.groups)
|
||||
if (floGlobals.groups[g].status !== false)
|
||||
promises.push(reqFn(g))
|
||||
Promise.allSettled(promises).then(result => {
|
||||
let ret = {};
|
||||
result.forEach(r => {
|
||||
if (r.status === 'fulfilled')
|
||||
ret[r.value[0]] = {
|
||||
status: r.status,
|
||||
value: r.value[1]
|
||||
}
|
||||
else if (r.status === "rejected")
|
||||
ret[r.reason[0]] = {
|
||||
status: r.status,
|
||||
reason: r.reason[1]
|
||||
}
|
||||
})
|
||||
resolve(ret)
|
||||
})
|
||||
})
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user