174b9fddf6
Old prompt based user login and server connect are replaced with login page Improved stability and simplification of functions Moved all superNode functions to app.js Supernode mode will now work in all pages (home,profile,msg) instead of just home
1191 lines
48 KiB
JavaScript
1191 lines
48 KiB
JavaScript
|
|
window.indexedDB = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
|
|
window.IDBTransaction = window.IDBTransaction || window.webkitIDBTransaction || window.msIDBTransaction;
|
|
window.IDBKeyRange = window.IDBKeyRange || window.webkitIDBKeyRange || window.msIDBKeyRange;
|
|
|
|
if (!window.indexedDB) {
|
|
window.alert("Your browser doesn't support a stable version of IndexedDB.")
|
|
}
|
|
var supernodeKBucket;
|
|
var superNodeList;
|
|
var months = ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'];
|
|
|
|
var encrypt = {
|
|
|
|
p: BigInteger("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F", 16),
|
|
|
|
exponent1: function () {
|
|
return this.p.add(BigInteger.ONE).divide(BigInteger("4"))
|
|
},
|
|
|
|
calculateY: function (x) {
|
|
let p = this.p;
|
|
let exp = this.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)
|
|
},
|
|
|
|
// Insert a compressed public key
|
|
getUncompressedPublicKey: function (compressedPublicKey) {
|
|
|
|
const p = this.p;
|
|
|
|
// 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 = this.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
|
|
};
|
|
},
|
|
|
|
getSenderPublicKeyString: function () {
|
|
privateKey = ellipticCurveEncryption.senderRandom();
|
|
senderPublicKeyString = ellipticCurveEncryption.senderPublicString(privateKey);
|
|
return {
|
|
privateKey: privateKey,
|
|
senderPublicKeyString: senderPublicKeyString
|
|
}
|
|
},
|
|
|
|
deriveSharedKeySender: function (receiverCompressedPublicKey, senderPrivateKey) {
|
|
try {
|
|
let receiverPublicKeyString = this.getUncompressedPublicKey(
|
|
receiverCompressedPublicKey);
|
|
var senderDerivedKey = {
|
|
XValue: "",
|
|
YValue: ""
|
|
};
|
|
senderDerivedKey = ellipticCurveEncryption.senderSharedKeyDerivation(
|
|
receiverPublicKeyString.x,
|
|
receiverPublicKeyString.y, senderPrivateKey);
|
|
return senderDerivedKey;
|
|
} catch (error) {
|
|
return new Error(error);
|
|
}
|
|
},
|
|
|
|
deriveReceiverSharedKey: function (senderPublicKeyString, receiverPrivateKey) {
|
|
return ellipticCurveEncryption.receiverSharedKeyDerivation(
|
|
senderPublicKeyString.XValuePublicString, senderPublicKeyString.YValuePublicString,
|
|
receiverPrivateKey);
|
|
},
|
|
|
|
getReceiverPublicKeyString: function (privateKey) {
|
|
return ellipticCurveEncryption.receiverPublicString(privateKey);
|
|
},
|
|
|
|
deriveSharedKeyReceiver: function (senderPublicKeyString, receiverPrivateKey) {
|
|
try {
|
|
return ellipticCurveEncryption.receiverSharedKeyDerivation(senderPublicKeyString.XValuePublicString,
|
|
senderPublicKeyString.YValuePublicString, receiverPrivateKey);
|
|
|
|
} catch (error) {
|
|
return new Error(error);
|
|
}
|
|
},
|
|
|
|
encryptMessage: function (data, receiverCompressedPublicKey) {
|
|
var senderECKeyData = this.getSenderPublicKeyString();
|
|
var senderDerivedKey = {
|
|
XValue: "",
|
|
YValue: ""
|
|
};
|
|
var senderPublicKeyString = {};
|
|
senderDerivedKey = this.deriveSharedKeySender(
|
|
receiverCompressedPublicKey, senderECKeyData.privateKey);
|
|
//console.log("senderDerivedKey", senderDerivedKey);
|
|
let senderKey = senderDerivedKey.XValue + senderDerivedKey.YValue;
|
|
let secret = Crypto.AES.encrypt(data, senderKey);
|
|
return {
|
|
secret: secret,
|
|
senderPublicKeyString: senderECKeyData.senderPublicKeyString
|
|
};
|
|
},
|
|
|
|
decryptMessage: function (secret, senderPublicKeyString) {
|
|
var receiverDerivedKey = {
|
|
XValue: "",
|
|
YValue: ""
|
|
};
|
|
var receiverECKeyData = {};
|
|
var myPrivateKey = privKey;
|
|
if (typeof myPrivateKey !== "string") throw new Error("No private key found.");
|
|
|
|
let privateKey = this.wifToDecimal(myPrivateKey, true);
|
|
if (typeof privateKey.privateKeyDecimal !== "string") throw new Error(
|
|
"Failed to detremine your private key.");
|
|
receiverECKeyData.privateKey = privateKey.privateKeyDecimal;
|
|
|
|
receiverDerivedKey = this.deriveReceiverSharedKey(senderPublicKeyString,
|
|
receiverECKeyData.privateKey);
|
|
//console.log("receiverDerivedKey", receiverDerivedKey);
|
|
|
|
let receiverKey = receiverDerivedKey.XValue + receiverDerivedKey.YValue;
|
|
let decryptMsg = Crypto.AES.decrypt(secret, receiverKey);
|
|
return decryptMsg;
|
|
},
|
|
|
|
ecparams: EllipticCurve.getSECCurveByName("secp256k1"),
|
|
getPubKeyHex: function(privateKeyHex){
|
|
var key = new Bitcoin.ECKey(privateKeyHex);
|
|
if(key.priv == null){
|
|
alert("Invalid Private key");
|
|
return;
|
|
}
|
|
key.setCompressed(true);
|
|
var pubkeyHex = key.getPubKeyHex();
|
|
return pubkeyHex;
|
|
},
|
|
getFLOIDfromPubkeyHex: function(pubkeyHex){
|
|
var key = new Bitcoin.ECKey().setPub(pubkeyHex);
|
|
var floID = key.getBitcoinAddress();
|
|
return floID;
|
|
},
|
|
validateAddr: function (value) {
|
|
try{
|
|
var addr = new Bitcoin.Address(value);
|
|
if (addr == value)
|
|
return true;
|
|
else
|
|
return false;
|
|
}catch(error){
|
|
return false;
|
|
}
|
|
},
|
|
verifyWIF: function (wif,addr){
|
|
try {
|
|
var key = new Bitcoin.ECKey(wif);
|
|
if(key.priv == null){
|
|
return false;
|
|
}
|
|
key.setCompressed(true);
|
|
var bitcoinAddress = key.getBitcoinAddress();
|
|
if (addr == bitcoinAddress)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
catch (error) {
|
|
console.log(error);
|
|
}
|
|
},
|
|
sign: function (msg, privateKeyHex) {
|
|
var key = new Bitcoin.ECKey(privateKeyHex);
|
|
key.setCompressed(true);
|
|
|
|
var privateKeyArr = key.getBitcoinPrivateKeyByteArray();
|
|
privateKey = BigInteger.fromByteArrayUnsigned(privateKeyArr);
|
|
var messageHash = Crypto.SHA256(msg);
|
|
|
|
var messageHashBigInteger = new BigInteger(messageHash);
|
|
var messageSign = Bitcoin.ECDSA.sign(messageHashBigInteger, key.priv);
|
|
|
|
var sighex = Crypto.util.bytesToHex(messageSign);
|
|
return sighex;
|
|
},
|
|
verify: function (msg, signatureHex, publicKeyHex) {
|
|
var msgHash = Crypto.SHA256(msg);
|
|
var messageHashBigInteger = new BigInteger(msgHash);
|
|
|
|
var sigBytes = Crypto.util.hexToBytes(signatureHex);
|
|
var signature = Bitcoin.ECDSA.parseSig(sigBytes);
|
|
|
|
var publicKeyPoint = this.ecparams.getCurve().decodePointHex(publicKeyHex);
|
|
|
|
var verify = Bitcoin.ECDSA.verifyRaw(messageHashBigInteger, signature.r, signature.s,
|
|
publicKeyPoint);
|
|
return verify;
|
|
},
|
|
wifToDecimal: function(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)
|
|
privateKeyDecimal = BigInteger(pk).toString()
|
|
privateKeyHex = Crypto.util.bytesToHex(pk)
|
|
return {
|
|
privateKeyDecimal: privateKeyDecimal,
|
|
privateKeyHex: privateKeyHex
|
|
}
|
|
},
|
|
createShamirsSecretShares: function (str, total_shares, threshold_limit) {
|
|
if (str.length > 0) {
|
|
// convert the text into a hex string
|
|
var strHex = shamirSecretShare.str2hex(str);
|
|
// split into total_shares shares, with a threshold of threshold_limit
|
|
var shares = shamirSecretShare.share(strHex, total_shares, threshold_limit);
|
|
return shares;
|
|
}
|
|
return false;
|
|
},
|
|
verifyShamirsSecret: function (sharesArray, str) {
|
|
// combine sharesArray:
|
|
var comb = shamirSecretShare.combine(sharesArray);
|
|
//convert back to UTF string:
|
|
comb = shamirSecretShare.hex2str(comb);
|
|
return comb === str;
|
|
},
|
|
retrieveShamirSecret: function (sharesArray) {
|
|
if (sharesArray.length > 0) {
|
|
// combine sharesArray:
|
|
var comb = shamirSecretShare.combine(sharesArray.slice(0, sharesArray.length));
|
|
//convert back to UTF string:
|
|
comb = shamirSecretShare.hex2str(comb);
|
|
return comb;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function convertStringToInt(string){
|
|
return parseInt(string,10);
|
|
}
|
|
|
|
function arrayToObject(array){
|
|
obj = {};
|
|
array.forEach(element => {
|
|
obj[element.floID] = {onionAddr : element.onionAddr, name : element.name, pubKey : element.pubKey};
|
|
});
|
|
return obj;
|
|
}
|
|
|
|
function getTime(time){
|
|
var t = new Date(time);
|
|
var fn = function(n){
|
|
if(n<10)
|
|
return '0'+n;
|
|
else
|
|
return n;
|
|
};
|
|
var tmp = `${months[t.getMonth()]} ${fn(t.getDate())} ${t.getFullYear()} ${fn(t.getHours())}:${fn(t.getMinutes())}`;
|
|
return tmp;
|
|
}
|
|
|
|
function logout(){
|
|
sessionStorage.clear();
|
|
window.location.href = "index.html";
|
|
}
|
|
|
|
/*Kademlia DHT K-bucket implementation as a binary tree.*/
|
|
|
|
if (typeof reactor == "undefined" || !reactor) {
|
|
(function () {
|
|
|
|
function Event(name) {
|
|
this.name = name;
|
|
this.callbacks = [];
|
|
}
|
|
Event.prototype.registerCallback = function (callback) {
|
|
this.callbacks.push(callback);
|
|
};
|
|
|
|
function Reactor() {
|
|
this.events = {};
|
|
}
|
|
|
|
Reactor.prototype.registerEvent = function (eventName) {
|
|
var event = new Event(eventName);
|
|
this.events[eventName] = event;
|
|
};
|
|
|
|
Reactor.prototype.dispatchEvent = function (eventName, eventArgs) {
|
|
this.events[eventName].callbacks.forEach(function (callback) {
|
|
callback(eventArgs);
|
|
});
|
|
};
|
|
|
|
Reactor.prototype.addEventListener = function (eventName, callback) {
|
|
this.events[eventName].registerCallback(callback);
|
|
};
|
|
|
|
window.reactor = new Reactor();
|
|
|
|
})();
|
|
}
|
|
|
|
reactor.registerEvent('added');
|
|
reactor.addEventListener('added', function (someObject) {
|
|
console.log('Added fired with data ' + someObject);
|
|
});
|
|
|
|
reactor.registerEvent('removed');
|
|
reactor.addEventListener('removed', function (someObject) {
|
|
console.log('Removed fired with data ' + someObject);
|
|
});
|
|
|
|
reactor.registerEvent('updated');
|
|
reactor.addEventListener('updated', function (someObject) {
|
|
console.log('Updated fired with data ' + someObject);
|
|
});
|
|
|
|
reactor.registerEvent('bucket_full');
|
|
reactor.addEventListener('bucket_full', function (someObject) {
|
|
console.log('Bucket full ' + someObject);
|
|
});
|
|
|
|
|
|
/**
|
|
* @param {Uint8Array} array1
|
|
* @param {Uint8Array} array2
|
|
* @return {Boolean}
|
|
*/
|
|
function arrayEquals(array1, array2) {
|
|
if (array1 === array2) {
|
|
return true
|
|
}
|
|
if (array1.length !== array2.length) {
|
|
return false
|
|
}
|
|
for (let i = 0, length = array1.length; i < length; ++i) {
|
|
if (array1[i] !== array2[i]) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
function createNode() {
|
|
return {
|
|
contacts: [],
|
|
dontSplit: false,
|
|
left: null,
|
|
right: null
|
|
}
|
|
}
|
|
|
|
function ensureInt8(name, val) {
|
|
if (!(val instanceof Uint8Array)) {
|
|
throw new TypeError(name + ' is not a Uint8Array')
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Implementation of a Kademlia DHT k-bucket used for storing
|
|
* contact (peer node) information.
|
|
*
|
|
* @extends EventEmitter
|
|
*/
|
|
function BuildKBucket(options = {}) {
|
|
/**
|
|
* `options`:
|
|
* `distance`: Function
|
|
* `function (firstId, secondId) { return distance }` An optional
|
|
* `distance` function that gets two `id` Uint8Arrays
|
|
* and return distance (as number) between them.
|
|
* `arbiter`: Function (Default: vectorClock arbiter)
|
|
* `function (incumbent, candidate) { return contact; }` An optional
|
|
* `arbiter` function that givent two `contact` objects with the same `id`
|
|
* returns the desired object to be used for updating the k-bucket. For
|
|
* more details, see [arbiter function](#arbiter-function).
|
|
* `localNodeId`: Uint8Array An optional Uint8Array representing the local node id.
|
|
* If not provided, a local node id will be created via `randomBytes(20)`.
|
|
* `metadata`: Object (Default: {}) Optional satellite data to include
|
|
* with the k-bucket. `metadata` property is guaranteed not be altered by,
|
|
* it is provided as an explicit container for users of k-bucket to store
|
|
* implementation-specific data.
|
|
* `numberOfNodesPerKBucket`: Integer (Default: 20) The number of nodes
|
|
* that a k-bucket can contain before being full or split.
|
|
* `numberOfNodesToPing`: Integer (Default: 3) The number of nodes to
|
|
* ping when a bucket that should not be split becomes full. KBucket will
|
|
* emit a `ping` event that contains `numberOfNodesToPing` nodes that have
|
|
* not been contacted the longest.
|
|
*
|
|
* @param {Object=} options optional
|
|
*/
|
|
|
|
this.localNodeId = options.localNodeId || window.crypto.getRandomValues(new Uint8Array(20))
|
|
this.numberOfNodesPerKBucket = options.numberOfNodesPerKBucket || 20
|
|
this.numberOfNodesToPing = options.numberOfNodesToPing || 3
|
|
this.distance = options.distance || this.distance
|
|
// use an arbiter from options or vectorClock arbiter by default
|
|
this.arbiter = options.arbiter || this.arbiter
|
|
this.metadata = Object.assign({}, options.metadata)
|
|
|
|
ensureInt8('option.localNodeId as parameter 1', this.localNodeId)
|
|
|
|
this.root = createNode()
|
|
|
|
|
|
/**
|
|
* Default arbiter function for contacts with the same id. Uses
|
|
* contact.vectorClock to select which contact to update the k-bucket with.
|
|
* Contact with larger vectorClock field will be selected. If vectorClock is
|
|
* the same, candidat will be selected.
|
|
*
|
|
* @param {Object} incumbent Contact currently stored in the k-bucket.
|
|
* @param {Object} candidate Contact being added to the k-bucket.
|
|
* @return {Object} Contact to updated the k-bucket with.
|
|
*/
|
|
this.arbiter = function (incumbent, candidate) {
|
|
return incumbent.vectorClock > candidate.vectorClock ? incumbent : candidate
|
|
}
|
|
|
|
/**
|
|
* Default distance function. Finds the XOR
|
|
* distance between firstId and secondId.
|
|
*
|
|
* @param {Uint8Array} firstId Uint8Array containing first id.
|
|
* @param {Uint8Array} secondId Uint8Array containing second id.
|
|
* @return {Number} Integer The XOR distance between firstId
|
|
* and secondId.
|
|
*/
|
|
this.distance = function (firstId, secondId) {
|
|
let distance = 0
|
|
let i = 0
|
|
const min = Math.min(firstId.length, secondId.length)
|
|
const max = Math.max(firstId.length, secondId.length)
|
|
for (; i < min; ++i) {
|
|
distance = distance * 256 + (firstId[i] ^ secondId[i])
|
|
}
|
|
for (; i < max; ++i) distance = distance * 256 + 255
|
|
return distance
|
|
}
|
|
|
|
/**
|
|
* Adds a contact to the k-bucket.
|
|
*
|
|
* @param {Object} contact the contact object to add
|
|
*/
|
|
this.add = function (contact) {
|
|
ensureInt8('contact.id', (contact || {}).id)
|
|
|
|
let bitIndex = 0
|
|
let node = this.root
|
|
|
|
while (node.contacts === null) {
|
|
// this is not a leaf node but an inner node with 'low' and 'high'
|
|
// branches; we will check the appropriate bit of the identifier and
|
|
// delegate to the appropriate node for further processing
|
|
node = this._determineNode(node, contact.id, bitIndex++)
|
|
}
|
|
|
|
// check if the contact already exists
|
|
const index = this._indexOf(node, contact.id)
|
|
if (index >= 0) {
|
|
this._update(node, index, contact)
|
|
return this
|
|
}
|
|
|
|
if (node.contacts.length < this.numberOfNodesPerKBucket) {
|
|
node.contacts.push(contact)
|
|
reactor.dispatchEvent('added', contact)
|
|
return this
|
|
}
|
|
|
|
// the bucket is full
|
|
if (node.dontSplit) {
|
|
// we are not allowed to split the bucket
|
|
// we need to ping the first this.numberOfNodesToPing
|
|
// in order to determine if they are alive
|
|
// only if one of the pinged nodes does not respond, can the new contact
|
|
// be added (this prevents DoS flodding with new invalid contacts)
|
|
reactor.dispatchEvent('bucket_full', {1: node.contacts.slice(0, this.numberOfNodesToPing),2: contact})
|
|
return this
|
|
}
|
|
|
|
this._split(node, bitIndex)
|
|
return this.add(contact)
|
|
}
|
|
|
|
/**
|
|
* Get the n closest contacts to the provided node id. "Closest" here means:
|
|
* closest according to the XOR metric of the contact node id.
|
|
*
|
|
* @param {Uint8Array} id Contact node id
|
|
* @param {Number=} n Integer (Default: Infinity) The maximum number of
|
|
* closest contacts to return
|
|
* @return {Array} Array Maximum of n closest contacts to the node id
|
|
*/
|
|
this.closest = function (id, n = Infinity) {
|
|
ensureInt8('id', id)
|
|
|
|
if ((!Number.isInteger(n) && n !== Infinity) || n <= 0) {
|
|
throw new TypeError('n is not positive number')
|
|
}
|
|
|
|
let contacts = []
|
|
|
|
for (let nodes = [this.root], bitIndex = 0; nodes.length > 0 && contacts.length < n;) {
|
|
const node = nodes.pop()
|
|
if (node.contacts === null) {
|
|
const detNode = this._determineNode(node, id, bitIndex++)
|
|
nodes.push(node.left === detNode ? node.right : node.left)
|
|
nodes.push(detNode)
|
|
} else {
|
|
contacts = contacts.concat(node.contacts)
|
|
}
|
|
}
|
|
|
|
return contacts
|
|
.map(a => [this.distance(a.id, id), a])
|
|
.sort((a, b) => a[0] - b[0])
|
|
.slice(0, n)
|
|
.map(a => a[1])
|
|
}
|
|
|
|
/**
|
|
* Counts the total number of contacts in the tree.
|
|
*
|
|
* @return {Number} The number of contacts held in the tree
|
|
*/
|
|
this.count = function () {
|
|
// return this.toArray().length
|
|
let count = 0
|
|
for (const nodes = [this.root]; nodes.length > 0;) {
|
|
const node = nodes.pop()
|
|
if (node.contacts === null) nodes.push(node.right, node.left)
|
|
else count += node.contacts.length
|
|
}
|
|
return count
|
|
}
|
|
|
|
/**
|
|
* Determines whether the id at the bitIndex is 0 or 1.
|
|
* Return left leaf if `id` at `bitIndex` is 0, right leaf otherwise
|
|
*
|
|
* @param {Object} node internal object that has 2 leafs: left and right
|
|
* @param {Uint8Array} id Id to compare localNodeId with.
|
|
* @param {Number} bitIndex Integer (Default: 0) The bit index to which bit
|
|
* to check in the id Uint8Array.
|
|
* @return {Object} left leaf if id at bitIndex is 0, right leaf otherwise.
|
|
*/
|
|
this._determineNode = function (node, id, bitIndex) {
|
|
// *NOTE* remember that id is a Uint8Array and has granularity of
|
|
// bytes (8 bits), whereas the bitIndex is the bit index (not byte)
|
|
|
|
// id's that are too short are put in low bucket (1 byte = 8 bits)
|
|
// (bitIndex >> 3) finds how many bytes the bitIndex describes
|
|
// bitIndex % 8 checks if we have extra bits beyond byte multiples
|
|
// if number of bytes is <= no. of bytes described by bitIndex and there
|
|
// are extra bits to consider, this means id has less bits than what
|
|
// bitIndex describes, id therefore is too short, and will be put in low
|
|
// bucket
|
|
const bytesDescribedByBitIndex = bitIndex >> 3
|
|
const bitIndexWithinByte = bitIndex % 8
|
|
if ((id.length <= bytesDescribedByBitIndex) && (bitIndexWithinByte !== 0)) {
|
|
return node.left
|
|
}
|
|
|
|
const byteUnderConsideration = id[bytesDescribedByBitIndex]
|
|
|
|
// byteUnderConsideration is an integer from 0 to 255 represented by 8 bits
|
|
// where 255 is 11111111 and 0 is 00000000
|
|
// in order to find out whether the bit at bitIndexWithinByte is set
|
|
// we construct (1 << (7 - bitIndexWithinByte)) which will consist
|
|
// of all bits being 0, with only one bit set to 1
|
|
// for example, if bitIndexWithinByte is 3, we will construct 00010000 by
|
|
// (1 << (7 - 3)) -> (1 << 4) -> 16
|
|
if (byteUnderConsideration & (1 << (7 - bitIndexWithinByte))) {
|
|
return node.right
|
|
}
|
|
|
|
return node.left
|
|
}
|
|
|
|
/**
|
|
* Get a contact by its exact ID.
|
|
* If this is a leaf, loop through the bucket contents and return the correct
|
|
* contact if we have it or null if not. If this is an inner node, determine
|
|
* which branch of the tree to traverse and repeat.
|
|
*
|
|
* @param {Uint8Array} id The ID of the contact to fetch.
|
|
* @return {Object|Null} The contact if available, otherwise null
|
|
*/
|
|
this.get = function (id) {
|
|
ensureInt8('id', id)
|
|
|
|
let bitIndex = 0
|
|
|
|
let node = this.root
|
|
while (node.contacts === null) {
|
|
node = this._determineNode(node, id, bitIndex++)
|
|
}
|
|
|
|
// index of uses contact id for matching
|
|
const index = this._indexOf(node, id)
|
|
return index >= 0 ? node.contacts[index] : null
|
|
}
|
|
|
|
/**
|
|
* Returns the index of the contact with provided
|
|
* id if it exists, returns -1 otherwise.
|
|
*
|
|
* @param {Object} node internal object that has 2 leafs: left and right
|
|
* @param {Uint8Array} id Contact node id.
|
|
* @return {Number} Integer Index of contact with provided id if it
|
|
* exists, -1 otherwise.
|
|
*/
|
|
this._indexOf = function (node, id) {
|
|
for (let i = 0; i < node.contacts.length; ++i) {
|
|
if (arrayEquals(node.contacts[i].id, id)) return i
|
|
}
|
|
|
|
return -1
|
|
}
|
|
|
|
/**
|
|
* Removes contact with the provided id.
|
|
*
|
|
* @param {Uint8Array} id The ID of the contact to remove.
|
|
* @return {Object} The k-bucket itself.
|
|
*/
|
|
this.remove = function (id) {
|
|
ensureInt8('the id as parameter 1', id)
|
|
|
|
let bitIndex = 0
|
|
let node = this.root
|
|
|
|
while (node.contacts === null) {
|
|
node = this._determineNode(node, id, bitIndex++)
|
|
}
|
|
|
|
const index = this._indexOf(node, id)
|
|
if (index >= 0) {
|
|
const contact = node.contacts.splice(index, 1)[0]
|
|
reactor.dispatchEvent('removed', contact)
|
|
}
|
|
|
|
return this
|
|
}
|
|
|
|
/**
|
|
* Splits the node, redistributes contacts to the new nodes, and marks the
|
|
* node that was split as an inner node of the binary tree of nodes by
|
|
* setting this.root.contacts = null
|
|
*
|
|
* @param {Object} node node for splitting
|
|
* @param {Number} bitIndex the bitIndex to which byte to check in the
|
|
* Uint8Array for navigating the binary tree
|
|
*/
|
|
this._split = function (node, bitIndex) {
|
|
node.left = createNode()
|
|
node.right = createNode()
|
|
|
|
// redistribute existing contacts amongst the two newly created nodes
|
|
for (const contact of node.contacts) {
|
|
this._determineNode(node, contact.id, bitIndex).contacts.push(contact)
|
|
}
|
|
|
|
node.contacts = null // mark as inner tree node
|
|
|
|
// don't split the "far away" node
|
|
// we check where the local node would end up and mark the other one as
|
|
// "dontSplit" (i.e. "far away")
|
|
const detNode = this._determineNode(node, this.localNodeId, bitIndex)
|
|
const otherNode = node.left === detNode ? node.right : node.left
|
|
otherNode.dontSplit = true
|
|
}
|
|
|
|
/**
|
|
* Returns all the contacts contained in the tree as an array.
|
|
* If this is a leaf, return a copy of the bucket. `slice` is used so that we
|
|
* don't accidentally leak an internal reference out that might be
|
|
* accidentally misused. If this is not a leaf, return the union of the low
|
|
* and high branches (themselves also as arrays).
|
|
*
|
|
* @return {Array} All of the contacts in the tree, as an array
|
|
*/
|
|
this.toArray = function () {
|
|
let result = []
|
|
for (const nodes = [this.root]; nodes.length > 0;) {
|
|
const node = nodes.pop()
|
|
if (node.contacts === null) nodes.push(node.right, node.left)
|
|
else result = result.concat(node.contacts)
|
|
}
|
|
return result
|
|
}
|
|
|
|
/**
|
|
* Updates the contact selected by the arbiter.
|
|
* If the selection is our old contact and the candidate is some new contact
|
|
* then the new contact is abandoned (not added).
|
|
* If the selection is our old contact and the candidate is our old contact
|
|
* then we are refreshing the contact and it is marked as most recently
|
|
* contacted (by being moved to the right/end of the bucket array).
|
|
* If the selection is our new contact, the old contact is removed and the new
|
|
* contact is marked as most recently contacted.
|
|
*
|
|
* @param {Object} node internal object that has 2 leafs: left and right
|
|
* @param {Number} index the index in the bucket where contact exists
|
|
* (index has already been computed in a previous
|
|
* calculation)
|
|
* @param {Object} contact The contact object to update.
|
|
*/
|
|
this._update = function (node, index, contact) {
|
|
// sanity check
|
|
if (!arrayEquals(node.contacts[index].id, contact.id)) {
|
|
throw new Error('wrong index for _update')
|
|
}
|
|
|
|
const incumbent = node.contacts[index]
|
|
|
|
/***************Change made by Abhishek*************/
|
|
const selection = this.arbiter(incumbent, contact)
|
|
//const selection = localbitcoinplusplus.kademlia.arbiter(incumbent, contact);
|
|
// if the selection is our old contact and the candidate is some new
|
|
// contact, then there is nothing to do
|
|
if (selection === incumbent && incumbent !== contact) return
|
|
|
|
node.contacts.splice(index, 1) // remove old contact
|
|
node.contacts.push(selection) // add more recent contact version
|
|
/***************Change made by Abhishek*************/
|
|
reactor.dispatchEvent('updated', {
|
|
...incumbent,
|
|
...selection
|
|
})
|
|
//reactor.dispatchEvent('updated', incumbent.concat(selection))
|
|
}
|
|
}
|
|
|
|
|
|
kBucketObj = {
|
|
|
|
decodeBase58Address: function (blockchain, address) {
|
|
let k = bitjs.Base58.decode(address)
|
|
k.shift()
|
|
k.splice(-4, 4)
|
|
return Crypto.util.bytesToHex(k)
|
|
},
|
|
launchKBucket: function() {
|
|
return new Promise((resolve, reject)=>{
|
|
try {
|
|
//const master_flo_pubKey = localbitcoinplusplus.master_configurations.masterFLOPubKey;
|
|
const master_flo_addr = adminID;
|
|
const SuKBucketId = this.floIdToKbucketId(crypto, master_flo_addr);
|
|
const SukbOptions = { localNodeId: SuKBucketId }
|
|
supernodeKBucket = new BuildKBucket(SukbOptions);
|
|
for(var i=0; i<superNodeList.length ; i++){
|
|
this.addNewUserNodeInKbucket(crypto,superNodeList[i],supernodeKBucket)
|
|
}
|
|
resolve('SuperNode KBucket formed');
|
|
} catch (error) {
|
|
reject(error);
|
|
}
|
|
});
|
|
},
|
|
launchSupernodesKBucket: function() {
|
|
|
|
localbitcoinplusplus.master_configurations.supernodesPubKeys.map(pubKey=>{
|
|
return new Promise((resolve, reject)=>{
|
|
try {
|
|
let flo_id = bitjs.pubkey2address(pubKey);
|
|
let kname = `SKBucket_${pubKey}`;
|
|
const KBucketId = this.floIdToKbucketId(crypto, flo_id)
|
|
const kbOptions = { localNodeId: KBucketId }
|
|
window[kname] = new BuildKBucket(kbOptions);
|
|
resolve(true);
|
|
} catch (error) {
|
|
reject(error);
|
|
}
|
|
})
|
|
})
|
|
},
|
|
addContact: function (id, floID, KB=supernodeKBucket) {
|
|
const contact = {
|
|
id: id,
|
|
floID: floID
|
|
};
|
|
KB.add(contact)
|
|
},
|
|
addNewUserNodeInKbucket: function(blockchain, address, KB=supernodeKBucket) {
|
|
let decodedId = address;
|
|
try {
|
|
decodedId = this.floIdToKbucketId(blockchain, address);
|
|
} catch(e) {
|
|
decodedId = address;
|
|
}
|
|
const addNewUserNode = this.addContact(decodedId, address, KB);
|
|
return {decodedId:decodedId, address:address};
|
|
},
|
|
floIdToKbucketId: function (blockchain, address) {
|
|
const decodedId = this.decodeBase58Address(blockchain, address);
|
|
const nodeIdBigInt = new BigInteger(decodedId, 16);
|
|
const nodeIdBytes = nodeIdBigInt.toByteArrayUnsigned();
|
|
const nodeIdNewInt8Array = new Uint8Array(nodeIdBytes);
|
|
return nodeIdNewInt8Array;
|
|
},
|
|
arbiter: function (incumbent, candidate) {
|
|
// we create a new object so that our selection is guaranteed to replace
|
|
// the incumbent
|
|
const merged = {
|
|
id: incumbent.id, // incumbent.id === candidate.id within an arbiter
|
|
data: incumbent.data
|
|
}
|
|
|
|
Object.keys(candidate.data).forEach(workerNodeId => {
|
|
merged.data[workerNodeId] = candidate.data[workerNodeId];
|
|
})
|
|
|
|
return merged;
|
|
},
|
|
newBase64DiscoverId: function (pubKey) {
|
|
let pubKeyBytes = Crypto.util.hexToBytes(pubKey);
|
|
return Crypto.util.bytesToBase64(pubKeyBytes);
|
|
},
|
|
restoreKbucket: function(flo_addr, blockchain="FLO_TEST", KB=KBucket) {
|
|
return new Promise((resolve, reject)=>{
|
|
readAllDB('kBucketStore')
|
|
.then(dbObject => {
|
|
if (typeof dbObject=="object") {
|
|
let su_flo_addr_array = localbitcoinplusplus.master_configurations.supernodesPubKeys
|
|
.map(pubk=>bitjs.pubkey2address(pubk));
|
|
// Prevent supernode to re-added in kbucket
|
|
dbObject
|
|
.filter(f=>!su_flo_addr_array.includes(f.data.id))
|
|
.map(dbObj=>{
|
|
this.addNewUserNodeInKbucket(blockchain, flo_addr, dbObj.data, KB);
|
|
});
|
|
} else {
|
|
reject(`Failed to restore kBucket.`);
|
|
}
|
|
resolve(dbObject);
|
|
});
|
|
})
|
|
},
|
|
restoreSupernodeKBucket: function() {
|
|
return new Promise((resolve, reject)=>{
|
|
const supernodeSeeds = localbitcoinplusplus.master_configurations.supernodeSeeds;
|
|
if (typeof supernodeSeeds !== "object") reject("Failed to get supernode seeds.");
|
|
let supernodeSeedsObj = JSON.parse(supernodeSeeds);
|
|
|
|
Object.entries(supernodeSeedsObj).map(seedObj=>{
|
|
let kbuck = this.addNewUserNodeInKbucket(crypto, seedObj[1].kbucketId,
|
|
{ id: seedObj[1].kbucketId }, supernodeKBucket);
|
|
});
|
|
|
|
resolve(true);
|
|
})
|
|
},
|
|
updateClosestSupernodeSeeds: function(flo_addr) {
|
|
return new Promise(async (resolve, reject) => {
|
|
await removeAllinDB('myClosestSupernodes');
|
|
let nearestSupernodeAddresslist = await this.addClosestSupernodeInDB(flo_addr);
|
|
nearestSupernodeAddresslist.map((nearestSupernodeAddress, index)=>{
|
|
updateinDB('myClosestSupernodes', {
|
|
id: index+1,
|
|
ip: nearestSupernodeAddress.ip,
|
|
port: nearestSupernodeAddress.port,
|
|
trader_flo_address: nearestSupernodeAddress.kbucketId,
|
|
is_live: null
|
|
}).then(updatedClosestSupernodes=>{
|
|
readAllDB('myClosestSupernodes').then(nearestSupernodeAddresslist=>{
|
|
showMessage(`INFO: Updated closest supernodes list successfully.`);
|
|
resolve(nearestSupernodeAddresslist);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
},
|
|
getSupernodeSeed: function (flo_addr) {
|
|
return new Promise(async (resolve, reject) => {
|
|
let nearestSupernodeAddresslist = await readAllDB('myClosestSupernodes');
|
|
if (nearestSupernodeAddresslist.length<1) {
|
|
nearestSupernodeAddresslist = await this.updateClosestSupernodeSeeds(flo_addr);
|
|
}
|
|
resolve(nearestSupernodeAddresslist);
|
|
});
|
|
},
|
|
isNodePresentInMyKbucket: function(flo_id, KB=KBucket) {
|
|
return new Promise((resolve, reject)=>{
|
|
let kArray = KB.toArray();
|
|
let kArrayFloIds = kArray.map(k=>k.data.id);
|
|
if (kArrayFloIds.includes(flo_id)) {
|
|
resolve(true);
|
|
} else {
|
|
reject(false);
|
|
}
|
|
});
|
|
},
|
|
determineClosestSupernode: function(flo_addr="", n=1, KB=supernodeKBucket, su="") {
|
|
return new Promise((resolve, reject)=>{
|
|
let msg = ``;
|
|
if (typeof supernodeKBucket !== "object") {
|
|
msg = `ERROR: Supernode KBucket not found.`;
|
|
showMessage(msg);
|
|
reject(msg);
|
|
return false;
|
|
}
|
|
|
|
if (su.length>0) {
|
|
try {
|
|
let closestSupernodeMasterList = supernodeKBucket.closest(supernodeKBucket.localNodeId);
|
|
const index = closestSupernodeMasterList.findIndex(f=>f.data.id==su);
|
|
let tail = closestSupernodeMasterList.splice(0, index);
|
|
const newClosestSupernodeMasterList = closestSupernodeMasterList.concat(tail);
|
|
resolve(newClosestSupernodeMasterList);
|
|
return true;
|
|
} catch (error) {
|
|
reject(error);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
try {
|
|
if(flo_addr.length < 0) {
|
|
showMessage(`WARNING: No Flo Id provided to determine closest Supenode.`);
|
|
return;
|
|
}
|
|
let isFloIdUint8 = flo_addr instanceof Uint8Array;
|
|
if (!isFloIdUint8) {
|
|
flo_addr = this.floIdToKbucketId(crypto, flo_addr);
|
|
}
|
|
const closestSupernode = supernodeKBucket.closest(flo_addr, n);
|
|
resolve(closestSupernode);
|
|
return true;
|
|
} catch (error) {
|
|
showMessage(error);
|
|
reject(error);
|
|
return false;
|
|
}
|
|
})
|
|
},
|
|
|
|
addClosestSupernodeInDB: function(flo_addr, KB=KBucket) {
|
|
return new Promise(async (resolve, reject)=>{
|
|
const supernodeSeeds = localbitcoinplusplus.master_configurations.supernodeSeeds;
|
|
if (typeof supernodeSeeds !== "object") reject("Failed to get supernode seeds.");
|
|
let supernodeSeedsObj = JSON.parse(supernodeSeeds);
|
|
|
|
Object.entries(supernodeSeedsObj).map(seedObj=>{
|
|
console.log(seedObj);
|
|
this.addNewUserNodeInKbucketAndDB(
|
|
crypto, seedObj[1].kbucketId,
|
|
{ id: seedObj[1].kbucketId });
|
|
});
|
|
|
|
let primarySu = await this.determineClosestSupernode(flo_addr);
|
|
let nearestSupernode = await this.determineClosestSupernode(flo_addr="", n=1, supernodeKBucket, primarySu[0].data.id);
|
|
let nearestSupernodeIds = nearestSupernode.map(f=>f.data.id);
|
|
let supernodeSeedsArray = Object.values(supernodeSeedsObj)
|
|
.filter(seed=>nearestSupernodeIds.includes(seed.kbucketId))
|
|
.sort(function(a, b){
|
|
return nearestSupernodeIds.indexOf(a.kbucketId) - nearestSupernodeIds.indexOf(b.kbucketId);
|
|
});
|
|
|
|
if (supernodeSeedsArray.length>0) {
|
|
resolve(supernodeSeedsArray);
|
|
} else {
|
|
reject(false);
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
/* Common IDB functions */
|
|
function storeTweet(data,tid){
|
|
var idb = indexedDB.open("FLO_Tweet");
|
|
idb.onerror = (event) => { console.log("Error in opening IndexedDB!") };
|
|
idb.onsuccess = (event) => {
|
|
var db = event.target.result;
|
|
var obs = db.transaction("tweets", "readwrite").objectStore("tweets");
|
|
data.tweetID = `${data.time}_${data.floID}`;
|
|
data.tid = tid;
|
|
obs.add(data);
|
|
var obsL = db.transaction("lastTweet", "readwrite").objectStore("lastTweet");
|
|
obsL.put(tid,data.floID);
|
|
db.close();
|
|
};
|
|
}
|
|
|
|
function storeMsg(data){
|
|
var idb = indexedDB.open("FLO_Tweet");
|
|
idb.onerror = (event) => { console.log("Error in opening IndexedDB!") };
|
|
idb.onsuccess = (event) => {
|
|
var db = event.target.result;
|
|
var obs = db.transaction("messages", "readwrite").objectStore("messages");
|
|
data.msgID = `${data.time}_${data.floID}`;
|
|
obs.add(data);
|
|
db.close();
|
|
};
|
|
}
|
|
|
|
/* SuperNode functions */
|
|
function sendDataToSuperNode(floID,data){
|
|
kBucketObj.determineClosestSupernode(floID).then(result=>{
|
|
var superNodeWS = new WebSocket("ws://"+profiles[result[0].floID].onionAddr+"/ws");
|
|
superNodeWS.onopen = function(ev){
|
|
console.log(`Connected to ${floID}'s SuperNode!`);
|
|
superNodeWS.send(data);
|
|
};
|
|
superNodeWS.onerror = function(ev) {console.log(`${floid}'s SuperNode is offline!`);};
|
|
superNodeWS.onclose = function(ev) {console.log(`Disconnected from ${floid}'s SuperNode!`);};
|
|
}).catch(e => {
|
|
console.log(e.message);
|
|
});
|
|
}
|
|
|
|
function superNodeMode(data){
|
|
if(data.reqNewTweets){
|
|
kBucketObj.determineClosestSupernode(data.floID).then(result => {
|
|
if(result[0].floID == selfID)
|
|
SuperNode_sendTweetsFromIDB(data.floID,data.tid,data.requestor);
|
|
}).catch(error => {
|
|
console.log(error);
|
|
});
|
|
}else if(data.newSuperNodeTweet){
|
|
kBucketObj.determineClosestSupernode(data.floID).then(result => {
|
|
if(result[0].floID == selfID)
|
|
SuperNode_storeSuperNodeTweet(data.data,data.tid);
|
|
}).catch(error => {
|
|
console.log(error);
|
|
});
|
|
}else if(data.viaSuperNodeMsg){
|
|
kBucketObj.determineClosestSupernode(data.to).then(result => {
|
|
if(result[0].floID == selfID)
|
|
SuperNode_storeViaSuperNodeMsg(data.from,data.to,data.data);
|
|
}).catch(error => {
|
|
console.log(error);
|
|
});
|
|
}else if(data.viaMsgreq){
|
|
kBucketObj.determineClosestSupernode(data.floID).then(result => {
|
|
if(result[0].floID == selfID)
|
|
SuperNode_sendviaMsgFromIDB(data.floID);
|
|
}).catch(error => {
|
|
console.log(error);
|
|
});
|
|
}
|
|
}
|
|
|
|
function SuperNode_sendTweetsFromIDB(floID,tid,requestor){
|
|
return new Promise((resolve,reject) => {
|
|
var requestorWS = new WebSocket("ws://"+profiles[requestor].onionAddr+"/ws");
|
|
requestorWS.onopen = (event) => {
|
|
console.log(`sending ${floID} tweets to ${requestor} Server!`);
|
|
var idb = indexedDB.open("FLO_Tweet",2);
|
|
idb.onerror = (event) => { reject("Error in opening IndexedDB!") };
|
|
idb.onupgradeneeded = (event) => {
|
|
var objectStore1 = event.target.result.createObjectStore("superNodeTweet",{ keyPath: 'tweetID' });
|
|
objectStore1.createIndex('floID', 'floID', { unique: false });
|
|
objectStore1.createIndex('tid', 'tid', { unique: false });
|
|
objectStore1.createIndex('data', 'data', { unique: false });
|
|
var objectStore2 = event.target.result.createObjectStore("viaSuperNodeMsg",{ keyPath: 'id',autoIncrement:true });
|
|
objectStore2.createIndex('from', 'from', { unique: false });
|
|
objectStore2.createIndex('to', 'to', { unique: false });
|
|
objectStore2.createIndex('data', 'data', { unique: false });
|
|
}
|
|
idb.onsuccess = (event) => {
|
|
var db = event.target.result;
|
|
var obs = db.transaction("superNodeTweet", "readwrite").objectStore("superNodeTweet");
|
|
var curReq = obs.openCursor();
|
|
curReq.onsuccess = (event) => {
|
|
var cursor = event.target.result;
|
|
if(cursor) {
|
|
if(cursor.value.floID == floID && cursor.value.tid > tid){
|
|
data = JSON.stringify({fromSuperNode:true, floID:cursor.value.floID,tid:cursor.value.tid,data:cursor.value.data})
|
|
requestorWS.send(data);
|
|
}
|
|
cursor.continue();
|
|
}else{
|
|
resolve("Displayed Tweets from IDB!");
|
|
}
|
|
}
|
|
curReq.onerror = (event) => { reject("Error in Reading tweets from IDB!") }
|
|
db.close();
|
|
};
|
|
};
|
|
requestorWS.onerror = (event) => { console.log(`${requestor} Server is offline!`) };
|
|
requestorWS.onclose = (event) => { console.log(`Disconnected from ${requestor} Server!`) };
|
|
});
|
|
}
|
|
|
|
function SuperNode_storeSuperNodeTweet(data,tid){
|
|
var idb = indexedDB.open("FLO_Tweet",2);
|
|
idb.onerror = (event) => { console.log("Error in opening IndexedDB!") };
|
|
idb.onupgradeneeded = (event) => {
|
|
var objectStore1 = event.target.result.createObjectStore("superNodeTweet",{ keyPath: 'tweetID' });
|
|
objectStore1.createIndex('floID', 'floID', { unique: false });
|
|
objectStore1.createIndex('tid', 'tid', { unique: false });
|
|
objectStore1.createIndex('data', 'data', { unique: false });
|
|
var objectStore2 = event.target.result.createObjectStore("viaSuperNodeMsg",{ keyPath: 'id',autoIncrement:true });
|
|
objectStore2.createIndex('from', 'from', { unique: false });
|
|
objectStore2.createIndex('to', 'to', { unique: false });
|
|
objectStore2.createIndex('data', 'data', { unique: false });
|
|
}
|
|
idb.onsuccess = (event) => {
|
|
var db = event.target.result;
|
|
var obs = db.transaction("superNodeTweet", "readwrite").objectStore("superNodeTweet");
|
|
var parsedData = JSON.parse(data);
|
|
var tweetID = ''+parsedData.floID+'_'+parsedData.time;
|
|
obs.add({tweetID:tweetID,floID:parsedData.floID,tid:tid,data:data});
|
|
db.close();
|
|
};
|
|
}
|
|
|
|
function SuperNode_storeViaSuperNodeMsg(from,to,data){
|
|
var idb = indexedDB.open("FLO_Tweet",2);
|
|
idb.onerror = (event) => { console.log("Error in opening IndexedDB!") };
|
|
idb.onupgradeneeded = (event) => {
|
|
var objectStore1 = event.target.result.createObjectStore("superNodeTweet",{ keyPath: 'tweetID' });
|
|
objectStore1.createIndex('floID', 'floID', { unique: false });
|
|
objectStore1.createIndex('tid', 'tid', { unique: false });
|
|
objectStore1.createIndex('data', 'data', { unique: false });
|
|
var objectStore2 = event.target.result.createObjectStore("viaSuperNodeMsg",{ keyPath: 'id',autoIncrement :true });
|
|
objectStore2.createIndex('from', 'from', { unique: false });
|
|
objectStore2.createIndex('to', 'to', { unique: false });
|
|
objectStore2.createIndex('data', 'data', { unique: false });
|
|
}
|
|
idb.onsuccess = (event) => {
|
|
var db = event.target.result;
|
|
var obs = db.transaction("viaSuperNodeMsg", "readwrite").objectStore("viaSuperNodeMsg");
|
|
obs.add({from:from,to:to,data:data});
|
|
db.close();
|
|
};
|
|
}
|
|
|
|
function SuperNode_sendviaMsgFromIDB(floID){
|
|
var receiverWS = new WebSocket("ws://"+profiles[floID].onionAddr+"/ws");
|
|
receiverWS.onopen = (event) => {
|
|
var idb = indexedDB.open("FLO_Tweet",2);
|
|
idb.onerror = (event) => { console.log("Error in opening IndexedDB!") };
|
|
idb.onupgradeneeded = (event) => {
|
|
var objectStore1 = event.target.result.createObjectStore("superNodeTweet",{ keyPath: 'tweetID' });
|
|
objectStore1.createIndex('floID', 'floID', { unique: false });
|
|
objectStore1.createIndex('tid', 'tid', { unique: false });
|
|
objectStore1.createIndex('data', 'data', { unique: false });
|
|
var objectStore2 = event.target.result.createObjectStore("viaSuperNodeMsg",{ keyPath: 'id',autoIncrement:true });
|
|
objectStore2.createIndex('from', 'from', { unique: false });
|
|
objectStore2.createIndex('to', 'to', { unique: false });
|
|
objectStore2.createIndex('data', 'data', { unique: false });
|
|
};
|
|
idb.onsuccess = (event) => {
|
|
var db = event.target.result;
|
|
var obs = db.transaction("viaSuperNodeMsg", "readwrite").objectStore("viaSuperNodeMsg");
|
|
obs.openCursor().onsuccess = (event) => {
|
|
var cursor = event.target.result;
|
|
if(cursor) {
|
|
if(cursor.value.to == floID){
|
|
receiverWS.send(cursor.value.data);
|
|
cursor.delete();
|
|
}
|
|
cursor.continue();
|
|
}else{
|
|
console.log('Sent All messages to '+floID)
|
|
}
|
|
}
|
|
db.close();
|
|
};
|
|
};
|
|
receiverWS.onerror = (event) => { console.log('Connection Error to '+floID) };
|
|
receiverWS.onclose = (event) => { console.log('Disconnected from '+floID) };
|
|
} |