update std-op
This commit is contained in:
sairajzero
parent
579d00b343
commit
e88799f01f
@ -1,513 +1,514 @@
|
|||||||
'use strict';
|
(function(EXPORTS) { //floBlockchainAPI v2.3.0
|
||||||
/* FLO Blockchain Operator to send/receive data from blockchain using API calls*/
|
/* FLO Blockchain Operator to send/receive data from blockchain using API calls*/
|
||||||
//version 2.2.1
|
'use strict';
|
||||||
(function(GLOBAL) {
|
const floBlockchainAPI = EXPORTS;
|
||||||
const floBlockchainAPI = GLOBAL.floBlockchainAPI = {
|
|
||||||
|
|
||||||
util: {
|
const serverList = floGlobals.apiURL[floGlobals.blockchain].slice(0);
|
||||||
serverList: floGlobals.apiURL[floGlobals.blockchain].slice(0),
|
var curPos = floCrypto.randInt(0, serverList - 1);
|
||||||
curPos: floCrypto.randInt(0, floGlobals.apiURL[floGlobals.blockchain].length - 1),
|
|
||||||
fetch_retry: function(apicall, rm_flosight) {
|
function fetch_retry(apicall, rm_flosight) {
|
||||||
return new Promise((resolve, reject) => {
|
return new Promise((resolve, reject) => {
|
||||||
let i = this.serverList.indexOf(rm_flosight)
|
let i = serverList.indexOf(rm_flosight)
|
||||||
if (i != -1) this.serverList.splice(i, 1);
|
if (i != -1) serverList.splice(i, 1);
|
||||||
this.curPos = floCrypto.randInt(0, this.serverList.length - 1);
|
curPos = floCrypto.randInt(0, serverList.length - 1);
|
||||||
this.fetch_api(apicall)
|
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))
|
.then(result => resolve(result))
|
||||||
.catch(error => reject(error));
|
.catch(error => reject(error));
|
||||||
})
|
})
|
||||||
},
|
|
||||||
fetch_api: function(apicall) {
|
|
||||||
return new Promise((resolve, reject) => {
|
|
||||||
if (this.serverList.length === 0)
|
|
||||||
reject("No floSight server working");
|
|
||||||
else {
|
|
||||||
let flosight = this.serverList[this.curPos];
|
|
||||||
fetch(flosight + apicall).then(response => {
|
|
||||||
if (response.ok)
|
|
||||||
response.json().then(data => resolve(data));
|
|
||||||
else {
|
|
||||||
this.fetch_retry(apicall, flosight)
|
|
||||||
.then(result => resolve(result))
|
|
||||||
.catch(error => reject(error));
|
|
||||||
}
|
|
||||||
}).catch(error => {
|
|
||||||
this.fetch_retry(apicall, flosight)
|
|
||||||
.then(result => resolve(result))
|
|
||||||
.catch(error => reject(error));
|
|
||||||
})
|
|
||||||
}
|
|
||||||
})
|
|
||||||
},
|
|
||||||
|
|
||||||
current: function() {
|
|
||||||
return this.serverList[this.curPos];
|
|
||||||
}
|
}
|
||||||
},
|
})
|
||||||
|
}
|
||||||
|
|
||||||
//Promised function to get data from API
|
Object.defineProperty(floBlockchainAPI, 'current_server', {
|
||||||
promisedAPI: function(apicall) {
|
get: () => serverList[curPos]
|
||||||
return new Promise((resolve, reject) => {
|
});
|
||||||
//console.log(apicall);
|
|
||||||
this.util.fetch_api(apicall)
|
|
||||||
.then(result => resolve(result))
|
|
||||||
.catch(error => reject(error));
|
|
||||||
});
|
|
||||||
},
|
|
||||||
|
|
||||||
//Get balance for the given Address
|
//Promised function to get data from API
|
||||||
getBalance: function(addr) {
|
const promisedAPI = floBlockchainAPI.promisedAPI = function(apicall) {
|
||||||
return new Promise((resolve, reject) => {
|
return new Promise((resolve, reject) => {
|
||||||
this.promisedAPI(`api/addr/${addr}/balance`)
|
//console.log(apicall);
|
||||||
.then(balance => resolve(parseFloat(balance)))
|
fetch_api(apicall)
|
||||||
.catch(error => reject(error));
|
.then(result => resolve(result))
|
||||||
});
|
.catch(error => reject(error));
|
||||||
},
|
});
|
||||||
|
}
|
||||||
|
|
||||||
//Write Data into blockchain
|
//Get balance for the given Address
|
||||||
writeData: function(senderAddr, data, privKey, receiverAddr = floGlobals.adminID, strict_utxo = true) {
|
const getBalance = floBlockchainAPI.getBalance = function(addr) {
|
||||||
return new Promise((resolve, reject) => {
|
return new Promise((resolve, reject) => {
|
||||||
if (typeof data != "string")
|
promisedAPI(`api/addr/${addr}/balance`)
|
||||||
data = JSON.stringify(data);
|
.then(balance => resolve(parseFloat(balance)))
|
||||||
this.sendTx(senderAddr, receiverAddr, floGlobals.sendAmt, privKey, data, strict_utxo)
|
.catch(error => reject(error));
|
||||||
.then(txid => resolve(txid))
|
});
|
||||||
.catch(error => reject(error));
|
}
|
||||||
});
|
|
||||||
},
|
|
||||||
|
|
||||||
//Send Tx to blockchain
|
//Send Tx to blockchain
|
||||||
sendTx: function(senderAddr, receiverAddr, sendAmt, privKey, floData = '', strict_utxo = true) {
|
const sendTx = floBlockchainAPI.sendTx = function(senderAddr, receiverAddr, sendAmt, privKey, floData = '', strict_utxo = true) {
|
||||||
return new Promise((resolve, reject) => {
|
return new Promise((resolve, reject) => {
|
||||||
if (!floCrypto.validateASCII(floData))
|
if (!floCrypto.validateASCII(floData))
|
||||||
return reject("Invalid FLO_Data: only printable ASCII characters are allowed");
|
return reject("Invalid FLO_Data: only printable ASCII characters are allowed");
|
||||||
else if (!floCrypto.validateAddr(senderAddr))
|
else if (!floCrypto.validateAddr(senderAddr))
|
||||||
return reject(`Invalid address : ${senderAddr}`);
|
return reject(`Invalid address : ${senderAddr}`);
|
||||||
else if (!floCrypto.validateAddr(receiverAddr))
|
else if (!floCrypto.validateAddr(receiverAddr))
|
||||||
return reject(`Invalid address : ${receiverAddr}`);
|
return reject(`Invalid address : ${receiverAddr}`);
|
||||||
else if (privKey.length < 1 || !floCrypto.verifyPrivKey(privKey, senderAddr))
|
else if (privKey.length < 1 || !floCrypto.verifyPrivKey(privKey, senderAddr))
|
||||||
return reject("Invalid Private key!");
|
return reject("Invalid Private key!");
|
||||||
else if (typeof sendAmt !== 'number' || sendAmt <= 0)
|
else if (typeof sendAmt !== 'number' || sendAmt <= 0)
|
||||||
return reject(`Invalid sendAmt : ${sendAmt}`);
|
return reject(`Invalid sendAmt : ${sendAmt}`);
|
||||||
|
|
||||||
//get unconfirmed tx list
|
//get unconfirmed tx list
|
||||||
this.promisedAPI(`api/addr/${senderAddr}`).then(result => {
|
promisedAPI(`api/addr/${senderAddr}`).then(result => {
|
||||||
this.readTxs(senderAddr, 0, result.unconfirmedTxApperances).then(result => {
|
readTxs(senderAddr, 0, result.unconfirmedTxApperances).then(result => {
|
||||||
let unconfirmedSpent = {};
|
let unconfirmedSpent = {};
|
||||||
for (let tx of result.items)
|
for (let tx of result.items)
|
||||||
if (tx.confirmations == 0)
|
if (tx.confirmations == 0)
|
||||||
for (let vin of tx.vin)
|
for (let vin of tx.vin)
|
||||||
if (vin.addr === senderAddr) {
|
if (vin.addr === senderAddr) {
|
||||||
if (Array.isArray(unconfirmedSpent[vin.txid]))
|
if (Array.isArray(unconfirmedSpent[vin.txid]))
|
||||||
unconfirmedSpent[vin.txid].push(vin.vout);
|
unconfirmedSpent[vin.txid].push(vin.vout);
|
||||||
else
|
else
|
||||||
unconfirmedSpent[vin.txid] = [vin.vout];
|
unconfirmedSpent[vin.txid] = [vin.vout];
|
||||||
}
|
}
|
||||||
//get utxos list
|
//get utxos list
|
||||||
this.promisedAPI(`api/addr/${senderAddr}/utxo`).then(utxos => {
|
promisedAPI(`api/addr/${senderAddr}/utxo`).then(utxos => {
|
||||||
//form/construct the transaction data
|
//form/construct the transaction data
|
||||||
var trx = bitjs.transaction();
|
var trx = bitjs.transaction();
|
||||||
var utxoAmt = 0.0;
|
var utxoAmt = 0.0;
|
||||||
var fee = floGlobals.fee;
|
var fee = floGlobals.fee;
|
||||||
for (var i = utxos.length - 1;
|
for (var i = utxos.length - 1;
|
||||||
(i >= 0) && (utxoAmt < sendAmt + fee); i--) {
|
(i >= 0) && (utxoAmt < sendAmt + fee); i--) {
|
||||||
//use only utxos with confirmations (strict_utxo mode)
|
//use only utxos with confirmations (strict_utxo mode)
|
||||||
if (utxos[i].confirmations || !strict_utxo) {
|
if (utxos[i].confirmations || !strict_utxo) {
|
||||||
if (utxos[i].txid in unconfirmedSpent && unconfirmedSpent[utxos[i].txid].includes(utxos[i].vout))
|
if (utxos[i].txid in unconfirmedSpent && unconfirmedSpent[utxos[i].txid].includes(utxos[i].vout))
|
||||||
continue; //A transaction has already used this utxo, but is unconfirmed.
|
continue; //A transaction has already used the utxo, but is unconfirmed.
|
||||||
trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i].scriptPubKey);
|
trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i].scriptPubKey);
|
||||||
utxoAmt += utxos[i].amount;
|
utxoAmt += utxos[i].amount;
|
||||||
};
|
};
|
||||||
}
|
}
|
||||||
if (utxoAmt < sendAmt + fee)
|
if (utxoAmt < sendAmt + fee)
|
||||||
reject("Insufficient FLO balance!");
|
reject("Insufficient FLO balance!");
|
||||||
else {
|
else {
|
||||||
trx.addoutput(receiverAddr, sendAmt);
|
trx.addoutput(receiverAddr, sendAmt);
|
||||||
var change = utxoAmt - sendAmt - fee;
|
var change = utxoAmt - sendAmt - fee;
|
||||||
if (change > 0)
|
if (change > 0)
|
||||||
trx.addoutput(senderAddr, change);
|
trx.addoutput(senderAddr, change);
|
||||||
trx.addflodata(floData.replace(/\n/g, ' '));
|
trx.addflodata(floData.replace(/\n/g, ' '));
|
||||||
var signedTxHash = trx.sign(privKey, 1);
|
var signedTxHash = trx.sign(privKey, 1);
|
||||||
this.broadcastTx(signedTxHash)
|
broadcastTx(signedTxHash)
|
||||||
.then(txid => resolve(txid))
|
.then(txid => resolve(txid))
|
||||||
.catch(error => reject(error))
|
.catch(error => reject(error))
|
||||||
}
|
}
|
||||||
}).catch(error => reject(error))
|
|
||||||
}).catch(error => reject(error))
|
}).catch(error => reject(error))
|
||||||
}).catch(error => reject(error))
|
}).catch(error => reject(error))
|
||||||
});
|
}).catch(error => reject(error))
|
||||||
},
|
});
|
||||||
|
}
|
||||||
|
|
||||||
//merge all UTXOs of a given floID into a single UTXO
|
//Write Data into blockchain
|
||||||
mergeUTXOs: function(floID, privKey, floData = '') {
|
floBlockchainAPI.writeData = function(senderAddr, data, privKey, receiverAddr = floGlobals.adminID, strict_utxo = true) {
|
||||||
return new Promise((resolve, reject) => {
|
return new Promise((resolve, reject) => {
|
||||||
if (!floCrypto.validateAddr(floID))
|
if (typeof data != "string")
|
||||||
return reject(`Invalid floID`);
|
data = JSON.stringify(data);
|
||||||
if (!floCrypto.verifyPrivKey(privKey, floID))
|
sendTx(senderAddr, receiverAddr, floGlobals.sendAmt, privKey, data, strict_utxo)
|
||||||
return reject("Invalid Private Key");
|
.then(txid => resolve(txid))
|
||||||
if (!floCrypto.validateASCII(floData))
|
.catch(error => reject(error));
|
||||||
return reject("Invalid FLO_Data: only printable ASCII characters are allowed");
|
});
|
||||||
var trx = bitjs.transaction();
|
}
|
||||||
var utxoAmt = 0.0;
|
|
||||||
var fee = floGlobals.fee;
|
//merge all UTXOs of a given floID into a single UTXO
|
||||||
this.promisedAPI(`api/addr/${floID}/utxo`).then(utxos => {
|
floBlockchainAPI.mergeUTXOs = function(floID, privKey, floData = '') {
|
||||||
for (var i = utxos.length - 1; i >= 0; i--)
|
return new Promise((resolve, reject) => {
|
||||||
if (utxos[i].confirmations) {
|
if (!floCrypto.validateAddr(floID))
|
||||||
trx.addinput(utxos[i].txid, utxos[i].vout, utxos[i].scriptPubKey);
|
return reject(`Invalid floID`);
|
||||||
utxoAmt += utxos[i].amount;
|
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)
|
||||||
}
|
}
|
||||||
trx.addoutput(floID, utxoAmt - fee);
|
})
|
||||||
|
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, ' '));
|
trx.addflodata(floData.replace(/\n/g, ' '));
|
||||||
var signedTxHash = trx.sign(privKey, 1);
|
for (let i = 0; i < wifSeq.length; i++)
|
||||||
this.broadcastTx(signedTxHash)
|
trx.signinput(i, wifSeq[i], 1);
|
||||||
|
var signedTxHash = trx.serialize();
|
||||||
|
broadcastTx(signedTxHash)
|
||||||
.then(txid => resolve(txid))
|
.then(txid => resolve(txid))
|
||||||
.catch(error => reject(error))
|
.catch(error => reject(error))
|
||||||
}).catch(error => reject(error))
|
}).catch(error => reject(error))
|
||||||
})
|
}).catch(error => reject(error))
|
||||||
},
|
})
|
||||||
|
}
|
||||||
|
|
||||||
/**Write data into blockchain from (and/or) to multiple floID
|
//Broadcast signed Tx in blockchain using API
|
||||||
* @param {Array} senderPrivKeys List of sender private-keys
|
const broadcastTx = floBlockchainAPI.broadcastTx = function(signedTxHash) {
|
||||||
* @param {string} data FLO data of the txn
|
return new Promise((resolve, reject) => {
|
||||||
* @param {Array} receivers List of receivers
|
if (signedTxHash.length < 1)
|
||||||
* @param {boolean} preserveRatio (optional) preserve ratio or equal contribution
|
return reject("Empty Signature");
|
||||||
* @return {Promise}
|
var url = serverList[curPos] + 'api/tx/send';
|
||||||
*/
|
fetch(url, {
|
||||||
writeDataMultiple: function(senderPrivKeys, data, receivers = [floGlobals.adminID], preserveRatio = true) {
|
method: "POST",
|
||||||
return new Promise((resolve, reject) => {
|
headers: {
|
||||||
if (!Array.isArray(senderPrivKeys))
|
'Content-Type': 'application/json'
|
||||||
return reject("Invalid senderPrivKeys: SenderPrivKeys must be Array");
|
},
|
||||||
if (!preserveRatio) {
|
body: `{"rawtx":"${signedTxHash}"}`
|
||||||
let tmp = {};
|
}).then(response => {
|
||||||
let amount = (floGlobals.sendAmt * receivers.length) / senderPrivKeys.length;
|
if (response.ok)
|
||||||
senderPrivKeys.forEach(key => tmp[key] = amount);
|
response.json().then(data => resolve(data.txid.result));
|
||||||
senderPrivKeys = tmp;
|
else
|
||||||
}
|
response.text().then(data => resolve(data));
|
||||||
if (!Array.isArray(receivers))
|
}).catch(error => reject(error));
|
||||||
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);
|
|
||||||
this.sendTxMultiple(senderPrivKeys, receivers, data)
|
|
||||||
.then(txid => resolve(txid))
|
|
||||||
.catch(error => reject(error))
|
|
||||||
})
|
|
||||||
},
|
|
||||||
|
|
||||||
/**Send Tx from (and/or) to multiple floID
|
floBlockchainAPI.getTx = function(txid) {
|
||||||
* @param {Array or Object} senderPrivKeys List of sender private-key (optional: with coins to be sent)
|
return new Promise((resolve, reject) => {
|
||||||
* @param {Object} receivers List of receivers with respective amount to be sent
|
promisedAPI(`api/tx/${txid}`)
|
||||||
* @param {string} floData FLO data of the txn
|
.then(response => resolve(response))
|
||||||
* @return {Promise}
|
.catch(error => reject(error))
|
||||||
*/
|
})
|
||||||
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(this.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(this.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();
|
|
||||||
this.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
|
//Read Txs of Address between from and to
|
||||||
broadcastTx: function(signedTxHash) {
|
const readTxs = floBlockchainAPI.readTxs = function(addr, from, to) {
|
||||||
return new Promise((resolve, reject) => {
|
return new Promise((resolve, reject) => {
|
||||||
if (signedTxHash.length < 1)
|
promisedAPI(`api/addrs/${addr}/txs?from=${from}&to=${to}`)
|
||||||
return reject("Empty Signature");
|
.then(response => resolve(response))
|
||||||
var url = this.util.serverList[this.util.curPos] + 'api/tx/send';
|
.catch(error => reject(error))
|
||||||
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));
|
|
||||||
})
|
|
||||||
},
|
|
||||||
|
|
||||||
getTx: function(txid) {
|
//Read All Txs of Address (newest first)
|
||||||
return new Promise((resolve, reject) => {
|
floBlockchainAPI.readAllTxs = function(addr) {
|
||||||
this.promisedAPI(`api/tx/${txid}`)
|
return new Promise((resolve, reject) => {
|
||||||
.then(response => resolve(response))
|
promisedAPI(`api/addrs/${addr}/txs?from=0&to=1`).then(response => {
|
||||||
.catch(error => reject(error))
|
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 Txs of Address between from and to
|
/*Read flo Data from txs of given Address
|
||||||
readTxs: function(addr, from, to) {
|
options can be used to filter data
|
||||||
return new Promise((resolve, reject) => {
|
limit : maximum number of filtered data (default = 1000, negative = no limit)
|
||||||
this.promisedAPI(`api/addrs/${addr}/txs?from=${from}&to=${to}`)
|
ignoreOld : ignore old txs (default = 0)
|
||||||
.then(response => resolve(response))
|
sentOnly : filters only sent data
|
||||||
.catch(error => reject(error))
|
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)
|
||||||
//Read All Txs of Address (newest first)
|
sender : flo-id(s) of sender
|
||||||
readAllTxs: function(addr) {
|
receiver : flo-id(s) of receiver
|
||||||
return new Promise((resolve, reject) => {
|
*/
|
||||||
this.promisedAPI(`api/addrs/${addr}/txs?from=0&to=1`).then(response => {
|
floBlockchainAPI.readData = function(addr, options = {}) {
|
||||||
this.promisedAPI(`api/addrs/${addr}/txs?from=0&to=${response.totalItems}0`)
|
options.limit = options.limit || 0;
|
||||||
.then(response => resolve(response.items))
|
options.ignoreOld = options.ignoreOld || 0;
|
||||||
.catch(error => reject(error));
|
if (typeof options.sender === "string") options.sender = [options.sender];
|
||||||
}).catch(error => reject(error))
|
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;
|
||||||
/*Read flo Data from txs of given Address
|
promisedAPI(`api/addrs/${addr}/txs?from=0&to=${newItems*2}`).then(response => {
|
||||||
options can be used to filter data
|
if (options.limit <= 0)
|
||||||
limit : maximum number of filtered data (default = 1000, negative = no limit)
|
options.limit = response.items.length;
|
||||||
ignoreOld : ignore old txs (default = 0)
|
var filteredData = [];
|
||||||
sentOnly : filters only sent data
|
let numToRead = response.totalItems - options.ignoreOld,
|
||||||
receivedOnly: filters only received data
|
unconfirmedCount = 0;
|
||||||
pattern : filters data that with JSON pattern
|
for (let i = 0; i < numToRead && filteredData.length < options.limit; i++) {
|
||||||
filter : custom filter funtion for floData (eg . filter: d => {return d[0] == '$'})
|
if (!response.items[i].confirmations) { //unconfirmed transactions
|
||||||
tx : (boolean) resolve tx data or not (resolves an Array of Object with tx details)
|
unconfirmedCount++;
|
||||||
sender : flo-id(s) of sender
|
if (numToRead < response.items[i].length)
|
||||||
receiver : flo-id(s) of receiver
|
|
||||||
*/
|
|
||||||
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) => {
|
|
||||||
this.promisedAPI(`api/addrs/${addr}/txs?from=0&to=1`).then(response => {
|
|
||||||
var newItems = response.totalItems - options.ignoreOld;
|
|
||||||
this.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++;
|
|
||||||
numToRead++;
|
numToRead++;
|
||||||
continue;
|
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({
|
if (options.pattern) {
|
||||||
totalTxs: response.totalItems - unconfirmedCount,
|
try {
|
||||||
data: filteredData
|
let jsonContent = JSON.parse(response.items[i].floData);
|
||||||
});
|
if (!Object.keys(jsonContent).includes(options.pattern))
|
||||||
}).catch(error => {
|
continue;
|
||||||
reject(error);
|
} 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 => {
|
}).catch(error => {
|
||||||
reject(error);
|
reject(error);
|
||||||
});
|
});
|
||||||
|
}).catch(error => {
|
||||||
|
reject(error);
|
||||||
});
|
});
|
||||||
}
|
});
|
||||||
}
|
}
|
||||||
})(typeof global !== "undefined" ? global : window);
|
|
||||||
|
|
||||||
|
})('object' === typeof module ? module.exports : window.floBlockchainAPI = {});
|
||||||
@ -1,339 +1,313 @@
|
|||||||
'use strict';
|
(function(EXPORTS) { //floCrypto v2.3.0a
|
||||||
|
/* FLO Crypto Operators */
|
||||||
|
'use strict';
|
||||||
|
const floCrypto = EXPORTS;
|
||||||
|
|
||||||
(function(GLOBAL) {
|
const p = BigInteger("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F", 16);
|
||||||
const floCrypto = GLOBAL.floCrypto = {
|
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"));
|
||||||
|
|
||||||
util: {
|
function calculateY(x) {
|
||||||
p: BigInteger("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F", 16),
|
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)
|
||||||
|
}
|
||||||
|
|
||||||
ecparams: EllipticCurve.getSECCurveByName("secp256k1"),
|
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
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
asciiAlternatives: `‘ '\n’ '\n“ "\n” "\n– --\n— ---\n≥ >=\n≤ <=\n≠ !=\n× *\n÷ /\n← <-\n→ ->\n↔ <->\n⇒ =>\n⇐ <=\n⇔ <=>`,
|
function getSenderPublicKeyString() {
|
||||||
|
let privateKey = ellipticCurveEncryption.senderRandom();
|
||||||
exponent1: function() {
|
var senderPublicKeyString = ellipticCurveEncryption.senderPublicString(privateKey);
|
||||||
return this.p.add(BigInteger.ONE).divide(BigInteger("4"))
|
return {
|
||||||
},
|
privateKey: privateKey,
|
||||||
|
senderPublicKeyString: senderPublicKeyString
|
||||||
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)
|
|
||||||
},
|
|
||||||
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() {
|
|
||||||
let privateKey = ellipticCurveEncryption.senderRandom();
|
|
||||||
var senderPublicKeyString = ellipticCurveEncryption.senderPublicString(privateKey);
|
|
||||||
return {
|
|
||||||
privateKey: privateKey,
|
|
||||||
senderPublicKeyString: senderPublicKeyString
|
|
||||||
}
|
|
||||||
},
|
|
||||||
|
|
||||||
deriveSharedKeySender: function(receiverCompressedPublicKey, senderPrivateKey) {
|
|
||||||
let receiverPublicKeyString = this.getUncompressedPublicKey(receiverCompressedPublicKey);
|
|
||||||
var senderDerivedKey = ellipticCurveEncryption.senderSharedKeyDerivation(
|
|
||||||
receiverPublicKeyString.x, receiverPublicKeyString.y, senderPrivateKey);
|
|
||||||
return senderDerivedKey;
|
|
||||||
},
|
|
||||||
|
|
||||||
deriveReceiverSharedKey: function(senderPublicKeyString, receiverPrivateKey) {
|
|
||||||
return ellipticCurveEncryption.receiverSharedKeyDerivation(
|
|
||||||
senderPublicKeyString.XValuePublicString, senderPublicKeyString.YValuePublicString, receiverPrivateKey);
|
|
||||||
},
|
|
||||||
|
|
||||||
getReceiverPublicKeyString: function(privateKey) {
|
|
||||||
return ellipticCurveEncryption.receiverPublicString(privateKey);
|
|
||||||
},
|
|
||||||
|
|
||||||
deriveSharedKeyReceiver: function(senderPublicKeyString, receiverPrivateKey) {
|
|
||||||
return ellipticCurveEncryption.receiverSharedKeyDerivation(
|
|
||||||
senderPublicKeyString.XValuePublicString, senderPublicKeyString.YValuePublicString, receiverPrivateKey);
|
|
||||||
},
|
|
||||||
|
|
||||||
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)
|
|
||||||
let privateKeyDecimal = BigInteger(pk).toString()
|
|
||||||
let privateKeyHex = Crypto.util.bytesToHex(pk)
|
|
||||||
return {
|
|
||||||
privateKeyDecimal: privateKeyDecimal,
|
|
||||||
privateKeyHex: privateKeyHex
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
|
|
||||||
//generate a random Interger within range
|
|
||||||
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)
|
|
||||||
randString: function(length, alphaNumeric = true) {
|
|
||||||
var result = '';
|
|
||||||
if (alphaNumeric)
|
|
||||||
var characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
|
|
||||||
else
|
|
||||||
var characters =
|
|
||||||
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_+-./*?@#&$<>=[]{}():';
|
|
||||||
for (var i = 0; i < length; i++)
|
|
||||||
result += characters.charAt(Math.floor(Math.random() * characters.length));
|
|
||||||
return result;
|
|
||||||
},
|
|
||||||
|
|
||||||
//Encrypt Data using public-key
|
|
||||||
encryptData: function(data, receiverCompressedPublicKey) {
|
|
||||||
var senderECKeyData = this.util.getSenderPublicKeyString();
|
|
||||||
var senderDerivedKey = this.util.deriveSharedKeySender(receiverCompressedPublicKey, 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
|
|
||||||
decryptData: function(data, myPrivateKey) {
|
|
||||||
var receiverECKeyData = {};
|
|
||||||
if (typeof myPrivateKey !== "string") throw new Error("No private key found.");
|
|
||||||
|
|
||||||
let privateKey = this.util.wifToDecimal(myPrivateKey, true);
|
|
||||||
if (typeof privateKey.privateKeyDecimal !== "string") throw new Error(
|
|
||||||
"Failed to detremine your private key.");
|
|
||||||
receiverECKeyData.privateKey = privateKey.privateKeyDecimal;
|
|
||||||
|
|
||||||
var receiverDerivedKey = this.util.deriveReceiverSharedKey(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
|
|
||||||
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
|
|
||||||
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 = this.util.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
|
|
||||||
generateNewID: function() {
|
|
||||||
try {
|
|
||||||
var key = new Bitcoin.ECKey(false);
|
|
||||||
key.setCompressed(true);
|
|
||||||
return {
|
|
||||||
floID: key.getBitcoinAddress(),
|
|
||||||
pubKey: key.getPubKeyHex(),
|
|
||||||
privKey: key.getBitcoinWalletImportFormat()
|
|
||||||
}
|
|
||||||
} catch (e) {
|
|
||||||
console.error(e);
|
|
||||||
}
|
|
||||||
},
|
|
||||||
|
|
||||||
//Returns public-key from private-key
|
|
||||||
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
|
|
||||||
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 (e) {
|
|
||||||
return null;
|
|
||||||
}
|
|
||||||
},
|
|
||||||
|
|
||||||
//Verify the private-key for the given public-key or flo-ID
|
|
||||||
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 (e) {
|
|
||||||
console.error(e);
|
|
||||||
}
|
|
||||||
},
|
|
||||||
|
|
||||||
//Check if the given Address is valid or not
|
|
||||||
validateAddr: function(inpAddr) {
|
|
||||||
if (!inpAddr)
|
|
||||||
return false;
|
|
||||||
try {
|
|
||||||
var addr = new Bitcoin.Address(inpAddr);
|
|
||||||
return true;
|
|
||||||
} catch {
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
},
|
|
||||||
|
|
||||||
//Split the str using shamir's Secret and Returns the shares
|
|
||||||
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
|
|
||||||
}
|
|
||||||
},
|
|
||||||
|
|
||||||
//Verifies the shares and str
|
|
||||||
verifyShamirsSecret: function(sharesArray, str) {
|
|
||||||
return (str && this.retrieveShamirSecret(sharesArray) === str)
|
|
||||||
},
|
|
||||||
|
|
||||||
//Returns the retrived secret by combining the shamirs shares
|
|
||||||
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;
|
|
||||||
}
|
|
||||||
},
|
|
||||||
|
|
||||||
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;
|
|
||||||
}
|
|
||||||
},
|
|
||||||
|
|
||||||
convertToASCII: function(string, mode = 'soft-remove') {
|
|
||||||
let chars = this.validateASCII(string, false);
|
|
||||||
if (chars === true)
|
|
||||||
return string;
|
|
||||||
else if (chars === null)
|
|
||||||
return null;
|
|
||||||
let convertor, result = string,
|
|
||||||
refAlt = {};
|
|
||||||
this.util.asciiAlternatives.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;
|
|
||||||
},
|
|
||||||
|
|
||||||
revertUnicode: function(string) {
|
|
||||||
return string.replace(/\\u[\dA-F]{4}/gi,
|
|
||||||
m => String.fromCharCode(parseInt(m.replace(/\\u/g, ''), 16)));
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
})(typeof global !== "undefined" ? global : window);
|
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 = {});
|
||||||
12564
docs/scripts/lib.js
12564
docs/scripts/lib.js
File diff suppressed because it is too large
Load Diff
@ -1,10 +1,10 @@
|
|||||||
const fs = require('fs');
|
const fs = require('fs');
|
||||||
const getInput = require('./getInput');
|
const getInput = require('./getInput');
|
||||||
|
|
||||||
const floGlobals = require('../docs/scripts/floGlobals');
|
global.floGlobals = require('../docs/scripts/floGlobals');
|
||||||
require('../src/set_globals');
|
require('../src/set_globals');
|
||||||
require('../docs/scripts/lib');
|
require('../docs/scripts/lib');
|
||||||
require('../docs/scripts/floCrypto');
|
const floCrypto = require('../docs/scripts/floCrypto');
|
||||||
|
|
||||||
console.log(__dirname);
|
console.log(__dirname);
|
||||||
|
|
||||||
|
|||||||
@ -2,8 +2,8 @@
|
|||||||
global.floGlobals = require('../docs/scripts/floGlobals');
|
global.floGlobals = require('../docs/scripts/floGlobals');
|
||||||
require('./set_globals');
|
require('./set_globals');
|
||||||
require('../docs/scripts/lib');
|
require('../docs/scripts/lib');
|
||||||
require('../docs/scripts/floCrypto');
|
global.floCrypto = require('../docs/scripts/floCrypto');
|
||||||
require('../docs/scripts/floBlockchainAPI');
|
global.floBlockchainAPI = require('../docs/scripts/floBlockchainAPI');
|
||||||
require('../docs/scripts/floTokenAPI');
|
require('../docs/scripts/floTokenAPI');
|
||||||
|
|
||||||
const Database = require("./database");
|
const Database = require("./database");
|
||||||
|
|||||||
Loading…
Reference in New Issue
Block a user