remove standard-operations files
This commit is contained in:
sairajzero
parent
c97969c605
commit
73c774325c
@ -1,996 +0,0 @@
|
|||||||
(function (EXPORTS) { //btcOperator v1.1.3b
|
|
||||||
/* BTC Crypto and API Operator */
|
|
||||||
const btcOperator = EXPORTS;
|
|
||||||
|
|
||||||
//This library uses API provided by chain.so (https://chain.so/)
|
|
||||||
const URL = "https://blockchain.info/";
|
|
||||||
|
|
||||||
const DUST_AMT = 546,
|
|
||||||
MIN_FEE_UPDATE = 219;
|
|
||||||
|
|
||||||
const fetch_api = btcOperator.fetch = function (api, json_res = true) {
|
|
||||||
return new Promise((resolve, reject) => {
|
|
||||||
console.debug(URL + api);
|
|
||||||
fetch(URL + api).then(response => {
|
|
||||||
if (response.ok) {
|
|
||||||
(json_res ? response.json() : response.text())
|
|
||||||
.then(result => resolve(result))
|
|
||||||
.catch(error => reject(error))
|
|
||||||
} else {
|
|
||||||
response.json()
|
|
||||||
.then(result => reject(result))
|
|
||||||
.catch(error => reject(error))
|
|
||||||
}
|
|
||||||
}).catch(error => reject(error))
|
|
||||||
})
|
|
||||||
};
|
|
||||||
|
|
||||||
const SATOSHI_IN_BTC = 1e8;
|
|
||||||
|
|
||||||
const util = btcOperator.util = {};
|
|
||||||
|
|
||||||
util.Sat_to_BTC = value => parseFloat((value / SATOSHI_IN_BTC).toFixed(8));
|
|
||||||
util.BTC_to_Sat = value => parseInt(value * SATOSHI_IN_BTC);
|
|
||||||
|
|
||||||
function get_fee_rate() {
|
|
||||||
return new Promise((resolve, reject) => {
|
|
||||||
fetch('https://api.blockchain.info/mempool/fees').then(response => {
|
|
||||||
if (response.ok)
|
|
||||||
response.json()
|
|
||||||
.then(result => resolve(util.Sat_to_BTC(result.regular)))
|
|
||||||
.catch(error => reject(error));
|
|
||||||
else
|
|
||||||
reject(response);
|
|
||||||
}).catch(error => reject(error))
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
const broadcastTx = btcOperator.broadcastTx = rawTxHex => new Promise((resolve, reject) => {
|
|
||||||
let url = 'https://coinb.in/api/?uid=1&key=12345678901234567890123456789012&setmodule=bitcoin&request=sendrawtransaction';
|
|
||||||
fetch(url, {
|
|
||||||
method: 'POST',
|
|
||||||
headers: {
|
|
||||||
'Content-Type': 'application/x-www-form-urlencoded'
|
|
||||||
},
|
|
||||||
body: "rawtx=" + rawTxHex
|
|
||||||
}).then(response => {
|
|
||||||
response.text().then(resultText => {
|
|
||||||
let r = resultText.match(/<result>.*<\/result>/);
|
|
||||||
if (!r)
|
|
||||||
reject(resultText);
|
|
||||||
else {
|
|
||||||
r = r.pop().replace('<result>', '').replace('</result>', '');
|
|
||||||
if (r == '1') {
|
|
||||||
let txid = resultText.match(/<txid>.*<\/txid>/).pop().replace('<txid>', '').replace('</txid>', '');
|
|
||||||
resolve(txid);
|
|
||||||
} else if (r == '0') {
|
|
||||||
let error = resultText.match(/<response>.*<\/response>/).pop().replace('<response>', '').replace('</response>', '');
|
|
||||||
reject(decodeURIComponent(error.replace(/\+/g, " ")));
|
|
||||||
} else reject(resultText);
|
|
||||||
}
|
|
||||||
}).catch(error => reject(error))
|
|
||||||
}).catch(error => reject(error))
|
|
||||||
});
|
|
||||||
|
|
||||||
Object.defineProperties(btcOperator, {
|
|
||||||
newKeys: {
|
|
||||||
get: () => {
|
|
||||||
let r = coinjs.newKeys();
|
|
||||||
r.segwitAddress = coinjs.segwitAddress(r.pubkey).address;
|
|
||||||
r.bech32Address = coinjs.bech32Address(r.pubkey).address;
|
|
||||||
return r;
|
|
||||||
}
|
|
||||||
},
|
|
||||||
pubkey: {
|
|
||||||
value: key => key.length >= 66 ? key : (key.length == 64 ? coinjs.newPubkey(key) : coinjs.wif2pubkey(key).pubkey)
|
|
||||||
},
|
|
||||||
address: {
|
|
||||||
value: (key, prefix = undefined) => coinjs.pubkey2address(btcOperator.pubkey(key), prefix)
|
|
||||||
},
|
|
||||||
segwitAddress: {
|
|
||||||
value: key => coinjs.segwitAddress(btcOperator.pubkey(key)).address
|
|
||||||
},
|
|
||||||
bech32Address: {
|
|
||||||
value: key => coinjs.bech32Address(btcOperator.pubkey(key)).address
|
|
||||||
}
|
|
||||||
});
|
|
||||||
|
|
||||||
coinjs.compressed = true;
|
|
||||||
|
|
||||||
const verifyKey = btcOperator.verifyKey = function (addr, key) {
|
|
||||||
if (!addr || !key)
|
|
||||||
return undefined;
|
|
||||||
switch (coinjs.addressDecode(addr).type) {
|
|
||||||
case "standard":
|
|
||||||
return btcOperator.address(key) === addr;
|
|
||||||
case "multisig":
|
|
||||||
return btcOperator.segwitAddress(key) === addr;
|
|
||||||
case "bech32":
|
|
||||||
return btcOperator.bech32Address(key) === addr;
|
|
||||||
default:
|
|
||||||
return null;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
const validateAddress = btcOperator.validateAddress = function (addr) {
|
|
||||||
if (!addr)
|
|
||||||
return undefined;
|
|
||||||
let type = coinjs.addressDecode(addr).type;
|
|
||||||
if (["standard", "multisig", "bech32", "multisigBech32"].includes(type))
|
|
||||||
return type;
|
|
||||||
else
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
btcOperator.multiSigAddress = function (pubKeys, minRequired, bech32 = true) {
|
|
||||||
if (!Array.isArray(pubKeys))
|
|
||||||
throw "pubKeys must be an array of public keys";
|
|
||||||
else if (pubKeys.length < minRequired)
|
|
||||||
throw "minimum required should be less than the number of pubKeys";
|
|
||||||
if (bech32)
|
|
||||||
return coinjs.pubkeys2MultisigAddressBech32(pubKeys, minRequired);
|
|
||||||
else
|
|
||||||
return coinjs.pubkeys2MultisigAddress(pubKeys, minRequired);
|
|
||||||
}
|
|
||||||
|
|
||||||
btcOperator.decodeRedeemScript = function (redeemScript, bech32 = true) {
|
|
||||||
let script = coinjs.script();
|
|
||||||
let decoded = (bech32) ?
|
|
||||||
script.decodeRedeemScriptBech32(redeemScript) :
|
|
||||||
script.decodeRedeemScript(redeemScript);
|
|
||||||
if (!decoded)
|
|
||||||
return null;
|
|
||||||
return {
|
|
||||||
address: decoded.address,
|
|
||||||
pubKeys: decoded.pubkeys,
|
|
||||||
redeemScript: decoded.redeemscript,
|
|
||||||
required: decoded.signaturesRequired
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
//convert from one blockchain to another blockchain (target version)
|
|
||||||
btcOperator.convert = {};
|
|
||||||
|
|
||||||
btcOperator.convert.wif = function (source_wif, target_version = coinjs.priv) {
|
|
||||||
let keyHex = util.decodeLegacy(source_wif).hex;
|
|
||||||
if (!keyHex || keyHex.length < 66 || !/01$/.test(keyHex))
|
|
||||||
return null;
|
|
||||||
else
|
|
||||||
return util.encodeLegacy(keyHex, target_version);
|
|
||||||
}
|
|
||||||
|
|
||||||
btcOperator.convert.legacy2legacy = function (source_addr, target_version = coinjs.pub) {
|
|
||||||
let rawHex = util.decodeLegacy(source_addr).hex;
|
|
||||||
if (!rawHex)
|
|
||||||
return null;
|
|
||||||
else
|
|
||||||
return util.encodeLegacy(rawHex, target_version);
|
|
||||||
}
|
|
||||||
|
|
||||||
btcOperator.convert.legacy2bech = function (source_addr, target_version = coinjs.bech32.version, target_hrp = coinjs.bech32.hrp) {
|
|
||||||
let rawHex = util.decodeLegacy(source_addr).hex;
|
|
||||||
if (!rawHex)
|
|
||||||
return null;
|
|
||||||
else
|
|
||||||
return util.encodeBech32(rawHex, target_version, target_hrp);
|
|
||||||
}
|
|
||||||
|
|
||||||
btcOperator.convert.bech2bech = function (source_addr, target_version = coinjs.bech32.version, target_hrp = coinjs.bech32.hrp) {
|
|
||||||
let rawHex = util.decodeBech32(source_addr).hex;
|
|
||||||
if (!rawHex)
|
|
||||||
return null;
|
|
||||||
else
|
|
||||||
return util.encodeBech32(rawHex, target_version, target_hrp);
|
|
||||||
}
|
|
||||||
|
|
||||||
btcOperator.convert.bech2legacy = function (source_addr, target_version = coinjs.pub) {
|
|
||||||
let rawHex = util.decodeBech32(source_addr).hex;
|
|
||||||
if (!rawHex)
|
|
||||||
return null;
|
|
||||||
else
|
|
||||||
return util.encodeLegacy(rawHex, target_version);
|
|
||||||
}
|
|
||||||
|
|
||||||
btcOperator.convert.multisig2multisig = function (source_addr, target_version = coinjs.multisig) {
|
|
||||||
let rawHex = util.decodeLegacy(source_addr).hex;
|
|
||||||
if (!rawHex)
|
|
||||||
return null;
|
|
||||||
else
|
|
||||||
return util.encodeLegacy(rawHex, target_version);
|
|
||||||
}
|
|
||||||
|
|
||||||
btcOperator.convert.bech2multisig = function (source_addr, target_version = coinjs.multisig) {
|
|
||||||
let rawHex = util.decodeBech32(source_addr).hex;
|
|
||||||
if (!rawHex)
|
|
||||||
return null;
|
|
||||||
else {
|
|
||||||
rawHex = Crypto.util.bytesToHex(ripemd160(Crypto.util.hexToBytes(rawHex), { asBytes: true }));
|
|
||||||
return util.encodeLegacy(rawHex, target_version);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
util.decodeLegacy = function (source) {
|
|
||||||
var decode = coinjs.base58decode(source);
|
|
||||||
var raw = decode.slice(0, decode.length - 4),
|
|
||||||
checksum = decode.slice(decode.length - 4);
|
|
||||||
var hash = Crypto.SHA256(Crypto.SHA256(raw, {
|
|
||||||
asBytes: true
|
|
||||||
}), {
|
|
||||||
asBytes: true
|
|
||||||
});
|
|
||||||
if (hash[0] != checksum[0] || hash[1] != checksum[1] || hash[2] != checksum[2] || hash[3] != checksum[3])
|
|
||||||
return false;
|
|
||||||
let version = raw.shift();
|
|
||||||
return {
|
|
||||||
version: version,
|
|
||||||
hex: Crypto.util.bytesToHex(raw)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
util.encodeLegacy = function (hex, version) {
|
|
||||||
var bytes = Crypto.util.hexToBytes(hex);
|
|
||||||
bytes.unshift(version);
|
|
||||||
var hash = Crypto.SHA256(Crypto.SHA256(bytes, {
|
|
||||||
asBytes: true
|
|
||||||
}), {
|
|
||||||
asBytes: true
|
|
||||||
});
|
|
||||||
var checksum = hash.slice(0, 4);
|
|
||||||
return coinjs.base58encode(bytes.concat(checksum));
|
|
||||||
}
|
|
||||||
|
|
||||||
util.decodeBech32 = function (source) {
|
|
||||||
let decode = coinjs.bech32_decode(source);
|
|
||||||
if (!decode)
|
|
||||||
return false;
|
|
||||||
var raw = decode.data;
|
|
||||||
let version = raw.shift();
|
|
||||||
raw = coinjs.bech32_convert(raw, 5, 8, false);
|
|
||||||
return {
|
|
||||||
hrp: decode.hrp,
|
|
||||||
version: version,
|
|
||||||
hex: Crypto.util.bytesToHex(raw)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
util.encodeBech32 = function (hex, version, hrp) {
|
|
||||||
var bytes = Crypto.util.hexToBytes(hex);
|
|
||||||
bytes = coinjs.bech32_convert(bytes, 8, 5, true);
|
|
||||||
bytes.unshift(version)
|
|
||||||
return coinjs.bech32_encode(hrp, bytes);
|
|
||||||
}
|
|
||||||
|
|
||||||
//BTC blockchain APIs
|
|
||||||
|
|
||||||
btcOperator.getBalance = addr => new Promise((resolve, reject) => {
|
|
||||||
fetch_api(`q/addressbalance/${addr}`)
|
|
||||||
.then(result => resolve(util.Sat_to_BTC(result)))
|
|
||||||
.catch(error => reject(error))
|
|
||||||
});
|
|
||||||
|
|
||||||
const BASE_TX_SIZE = 12,
|
|
||||||
BASE_INPUT_SIZE = 41,
|
|
||||||
LEGACY_INPUT_SIZE = 107,
|
|
||||||
BECH32_INPUT_SIZE = 27,
|
|
||||||
BECH32_MULTISIG_INPUT_SIZE = 35,
|
|
||||||
SEGWIT_INPUT_SIZE = 59,
|
|
||||||
MULTISIG_INPUT_SIZE_ES = 351,
|
|
||||||
BASE_OUTPUT_SIZE = 9,
|
|
||||||
LEGACY_OUTPUT_SIZE = 25,
|
|
||||||
BECH32_OUTPUT_SIZE = 23,
|
|
||||||
BECH32_MULTISIG_OUTPUT_SIZE = 34,
|
|
||||||
SEGWIT_OUTPUT_SIZE = 23;
|
|
||||||
|
|
||||||
function _redeemScript(addr, key) {
|
|
||||||
let decode = coinjs.addressDecode(addr);
|
|
||||||
switch (decode.type) {
|
|
||||||
case "standard":
|
|
||||||
return false;
|
|
||||||
case "multisig":
|
|
||||||
return key ? coinjs.segwitAddress(btcOperator.pubkey(key)).redeemscript : null;
|
|
||||||
case "bech32":
|
|
||||||
return decode.redeemscript;
|
|
||||||
default:
|
|
||||||
return null;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
function _sizePerInput(addr, rs) {
|
|
||||||
switch (coinjs.addressDecode(addr).type) {
|
|
||||||
case "standard":
|
|
||||||
return BASE_INPUT_SIZE + LEGACY_INPUT_SIZE;
|
|
||||||
case "bech32":
|
|
||||||
return BASE_INPUT_SIZE + BECH32_INPUT_SIZE;
|
|
||||||
case "multisigBech32":
|
|
||||||
return BASE_INPUT_SIZE + BECH32_MULTISIG_INPUT_SIZE;
|
|
||||||
case "multisig":
|
|
||||||
switch (coinjs.script().decodeRedeemScript(rs).type) {
|
|
||||||
case "segwit__":
|
|
||||||
return BASE_INPUT_SIZE + SEGWIT_INPUT_SIZE;
|
|
||||||
case "multisig__":
|
|
||||||
return BASE_INPUT_SIZE + MULTISIG_INPUT_SIZE_ES;
|
|
||||||
default:
|
|
||||||
return null;
|
|
||||||
};
|
|
||||||
default:
|
|
||||||
return null;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
function _sizePerOutput(addr) {
|
|
||||||
switch (coinjs.addressDecode(addr).type) {
|
|
||||||
case "standard":
|
|
||||||
return BASE_OUTPUT_SIZE + LEGACY_OUTPUT_SIZE;
|
|
||||||
case "bech32":
|
|
||||||
return BASE_OUTPUT_SIZE + BECH32_OUTPUT_SIZE;
|
|
||||||
case "multisigBech32":
|
|
||||||
return BASE_OUTPUT_SIZE + BECH32_MULTISIG_OUTPUT_SIZE;
|
|
||||||
case "multisig":
|
|
||||||
return BASE_OUTPUT_SIZE + SEGWIT_OUTPUT_SIZE;
|
|
||||||
default:
|
|
||||||
return null;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
function validateTxParameters(parameters) {
|
|
||||||
let invalids = [];
|
|
||||||
//sender-ids
|
|
||||||
if (parameters.senders) {
|
|
||||||
if (!Array.isArray(parameters.senders))
|
|
||||||
parameters.senders = [parameters.senders];
|
|
||||||
parameters.senders.forEach(id => !validateAddress(id) ? invalids.push(id) : null);
|
|
||||||
if (invalids.length)
|
|
||||||
throw "Invalid senders:" + invalids;
|
|
||||||
}
|
|
||||||
if (parameters.privkeys) {
|
|
||||||
if (!Array.isArray(parameters.privkeys))
|
|
||||||
parameters.privkeys = [parameters.privkeys];
|
|
||||||
if (parameters.senders.length != parameters.privkeys.length)
|
|
||||||
throw "Array length for senders and privkeys should be equal";
|
|
||||||
parameters.senders.forEach((id, i) => {
|
|
||||||
let key = parameters.privkeys[i];
|
|
||||||
if (!verifyKey(id, key)) //verify private-key
|
|
||||||
invalids.push(id);
|
|
||||||
if (key.length === 64) //convert Hex to WIF if needed
|
|
||||||
parameters.privkeys[i] = coinjs.privkey2wif(key);
|
|
||||||
});
|
|
||||||
if (invalids.length)
|
|
||||||
throw "Invalid private key for address:" + invalids;
|
|
||||||
}
|
|
||||||
//receiver-ids (and change-id)
|
|
||||||
if (!Array.isArray(parameters.receivers))
|
|
||||||
parameters.receivers = [parameters.receivers];
|
|
||||||
parameters.receivers.forEach(id => !validateAddress(id) ? invalids.push(id) : null);
|
|
||||||
if (invalids.length)
|
|
||||||
throw "Invalid receivers:" + invalids;
|
|
||||||
if (parameters.change_address && !validateAddress(parameters.change_address))
|
|
||||||
throw "Invalid change_address:" + parameters.change_address;
|
|
||||||
//fee and amounts
|
|
||||||
if ((typeof parameters.fee !== "number" || parameters.fee <= 0) && parameters.fee !== null) //fee = null (auto calc)
|
|
||||||
throw "Invalid fee:" + parameters.fee;
|
|
||||||
if (!Array.isArray(parameters.amounts))
|
|
||||||
parameters.amounts = [parameters.amounts];
|
|
||||||
if (parameters.receivers.length != parameters.amounts.length)
|
|
||||||
throw "Array length for receivers and amounts should be equal";
|
|
||||||
parameters.amounts.forEach(a => typeof a !== "number" || a <= 0 ? invalids.push(a) : null);
|
|
||||||
if (invalids.length)
|
|
||||||
throw "Invalid amounts:" + invalids;
|
|
||||||
//return
|
|
||||||
return parameters;
|
|
||||||
}
|
|
||||||
|
|
||||||
function createTransaction(senders, redeemScripts, receivers, amounts, fee, change_address, fee_from_receiver) {
|
|
||||||
return new Promise((resolve, reject) => {
|
|
||||||
let total_amount = parseFloat(amounts.reduce((t, a) => t + a, 0).toFixed(8));
|
|
||||||
const tx = coinjs.transaction();
|
|
||||||
let output_size = addOutputs(tx, receivers, amounts, change_address);
|
|
||||||
addInputs(tx, senders, redeemScripts, total_amount, fee, output_size, fee_from_receiver).then(result => {
|
|
||||||
if (result.change_amount > 0 && result.change_amount > result.fee) //add change amount if any (ignore dust change)
|
|
||||||
tx.outs[tx.outs.length - 1].value = util.BTC_to_Sat(result.change_amount); //values are in satoshi
|
|
||||||
if (fee_from_receiver) { //deduce fee from receivers if fee_from_receiver
|
|
||||||
let fee_remaining = util.BTC_to_Sat(result.fee);
|
|
||||||
for (let i = 0; i < tx.outs.length - 1 && fee_remaining > 0; i++) {
|
|
||||||
if (fee_remaining < tx.outs[i].value) {
|
|
||||||
tx.outs[i].value -= fee_remaining;
|
|
||||||
fee_remaining = 0;
|
|
||||||
} else {
|
|
||||||
fee_remaining -= tx.outs[i].value;
|
|
||||||
tx.outs[i].value = 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if (fee_remaining > 0)
|
|
||||||
return reject("Send amount is less than fee");
|
|
||||||
|
|
||||||
}
|
|
||||||
//remove all output with value less than DUST amount
|
|
||||||
let filtered_outputs = [], dust_value = 0;
|
|
||||||
tx.outs.forEach(o => o.value >= DUST_AMT ? filtered_outputs.push(o) : dust_value += o.value);
|
|
||||||
tx.outs = filtered_outputs;
|
|
||||||
//update result values
|
|
||||||
result.fee += util.Sat_to_BTC(dust_value);
|
|
||||||
result.output_size = output_size;
|
|
||||||
result.output_amount = total_amount - (fee_from_receiver ? result.fee : 0);
|
|
||||||
result.total_size = BASE_TX_SIZE + output_size + result.input_size;
|
|
||||||
result.transaction = tx;
|
|
||||||
resolve(result);
|
|
||||||
}).catch(error => reject(error))
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
function addInputs(tx, senders, redeemScripts, total_amount, fee, output_size, fee_from_receiver) {
|
|
||||||
return new Promise((resolve, reject) => {
|
|
||||||
if (fee !== null) {
|
|
||||||
addUTXOs(tx, senders, redeemScripts, fee_from_receiver ? total_amount : total_amount + fee, false).then(result => {
|
|
||||||
result.fee = fee;
|
|
||||||
resolve(result);
|
|
||||||
}).catch(error => reject(error))
|
|
||||||
} else {
|
|
||||||
get_fee_rate().then(fee_rate => {
|
|
||||||
let net_fee = BASE_TX_SIZE * fee_rate;
|
|
||||||
net_fee += (output_size * fee_rate);
|
|
||||||
(fee_from_receiver ?
|
|
||||||
addUTXOs(tx, senders, redeemScripts, total_amount, false) :
|
|
||||||
addUTXOs(tx, senders, redeemScripts, total_amount + net_fee, fee_rate)
|
|
||||||
).then(result => {
|
|
||||||
result.fee = parseFloat((net_fee + (result.input_size * fee_rate)).toFixed(8));
|
|
||||||
result.fee_rate = fee_rate;
|
|
||||||
resolve(result);
|
|
||||||
}).catch(error => reject(error))
|
|
||||||
}).catch(error => reject(error))
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
function addUTXOs(tx, senders, redeemScripts, required_amount, fee_rate, rec_args = {}) {
|
|
||||||
return new Promise((resolve, reject) => {
|
|
||||||
required_amount = parseFloat(required_amount.toFixed(8));
|
|
||||||
if (typeof rec_args.n === "undefined") {
|
|
||||||
rec_args.n = 0;
|
|
||||||
rec_args.input_size = 0;
|
|
||||||
rec_args.input_amount = 0;
|
|
||||||
}
|
|
||||||
if (required_amount <= 0)
|
|
||||||
return resolve({
|
|
||||||
input_size: rec_args.input_size,
|
|
||||||
input_amount: rec_args.input_amount,
|
|
||||||
change_amount: required_amount * -1 //required_amount will be -ve of change_amount
|
|
||||||
});
|
|
||||||
else if (rec_args.n >= senders.length)
|
|
||||||
return reject("Insufficient Balance");
|
|
||||||
let addr = senders[rec_args.n],
|
|
||||||
rs = redeemScripts[rec_args.n];
|
|
||||||
let addr_type = coinjs.addressDecode(addr).type;
|
|
||||||
let size_per_input = _sizePerInput(addr, rs);
|
|
||||||
fetch_api(`unspent?active=${addr}`).then(result => {
|
|
||||||
let utxos = result.unspent_outputs;
|
|
||||||
//console.debug("add-utxo", addr, rs, required_amount, utxos);
|
|
||||||
for (let i = 0; i < utxos.length && required_amount > 0; i++) {
|
|
||||||
if (!utxos[i].confirmations) //ignore unconfirmed utxo
|
|
||||||
continue;
|
|
||||||
var script;
|
|
||||||
if (!rs || !rs.length) //legacy script
|
|
||||||
script = utxos[i].script;
|
|
||||||
else if (((rs.match(/^00/) && rs.length == 44)) || (rs.length == 40 && rs.match(/^[a-f0-9]+$/gi)) || addr_type === 'multisigBech32') {
|
|
||||||
//redeemScript for segwit/bech32 and multisig (bech32)
|
|
||||||
let s = coinjs.script();
|
|
||||||
s.writeBytes(Crypto.util.hexToBytes(rs));
|
|
||||||
s.writeOp(0);
|
|
||||||
s.writeBytes(coinjs.numToBytes(utxos[i].value.toFixed(0), 8));
|
|
||||||
script = Crypto.util.bytesToHex(s.buffer);
|
|
||||||
} else //redeemScript for multisig (segwit)
|
|
||||||
script = rs;
|
|
||||||
tx.addinput(utxos[i].tx_hash_big_endian, utxos[i].tx_output_n, script, 0xfffffffd /*sequence*/); //0xfffffffd for Replace-by-fee
|
|
||||||
//update track values
|
|
||||||
rec_args.input_size += size_per_input;
|
|
||||||
rec_args.input_amount += util.Sat_to_BTC(utxos[i].value);
|
|
||||||
required_amount -= util.Sat_to_BTC(utxos[i].value);
|
|
||||||
if (fee_rate) //automatic fee calculation (dynamic)
|
|
||||||
required_amount += size_per_input * fee_rate;
|
|
||||||
}
|
|
||||||
rec_args.n += 1;
|
|
||||||
addUTXOs(tx, senders, redeemScripts, required_amount, fee_rate, rec_args)
|
|
||||||
.then(result => resolve(result))
|
|
||||||
.catch(error => reject(error))
|
|
||||||
}).catch(error => reject(error))
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
function addOutputs(tx, receivers, amounts, change_address) {
|
|
||||||
let size = 0;
|
|
||||||
for (let i in receivers) {
|
|
||||||
tx.addoutput(receivers[i], amounts[i]);
|
|
||||||
size += _sizePerOutput(receivers[i]);
|
|
||||||
}
|
|
||||||
tx.addoutput(change_address, 0);
|
|
||||||
size += _sizePerOutput(change_address);
|
|
||||||
return size;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
function autoFeeCalc(tx) {
|
|
||||||
return new Promise((resolve, reject) => {
|
|
||||||
get_fee_rate().then(fee_rate => {
|
|
||||||
let tx_size = tx.size();
|
|
||||||
for (var i = 0; i < this.ins.length; i++)
|
|
||||||
switch (tx.extractScriptKey(i).type) {
|
|
||||||
case 'scriptpubkey':
|
|
||||||
tx_size += SIGN_SIZE;
|
|
||||||
break;
|
|
||||||
case 'segwit':
|
|
||||||
case 'multisig':
|
|
||||||
tx_size += SIGN_SIZE * 0.25;
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
console.warn('Unknown script-type');
|
|
||||||
tx_size += SIGN_SIZE;
|
|
||||||
}
|
|
||||||
resolve(tx_size * fee_rate);
|
|
||||||
}).catch(error => reject(error))
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
function editFee(tx, current_fee, target_fee, index = -1) {
|
|
||||||
//values are in satoshi
|
|
||||||
index = parseInt(index >= 0 ? index : tx.outs.length - index);
|
|
||||||
if (index < 0 || index >= tx.outs.length)
|
|
||||||
throw "Invalid index";
|
|
||||||
let edit_value = parseInt(current_fee - target_fee), //rip of any decimal places
|
|
||||||
current_value = tx.outs[index].value; //could be BigInterger
|
|
||||||
if (edit_value < 0 && edit_value > current_value)
|
|
||||||
throw "Insufficient value at vout";
|
|
||||||
tx.outs[index].value = current_value instanceof BigInteger ?
|
|
||||||
current_value.add(new BigInteger('' + edit_value)) : parseInt(current_value + edit_value);
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
||||||
function tx_fetch_for_editing(tx) {
|
|
||||||
return new Promise((resolve, reject) => {
|
|
||||||
if (typeof tx == 'string' && /^[0-9a-f]{64}$/i.test(tx)) { //tx is txid
|
|
||||||
getTx.hex(tx)
|
|
||||||
.then(txhex => resolve(deserializeTx(txhex)))
|
|
||||||
.catch(error => reject(error))
|
|
||||||
} else resolve(deserializeTx(tx));
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
btcOperator.editFee = function (tx_hex, new_fee, private_keys, change_only = true) {
|
|
||||||
return new Promise((resolve, reject) => {
|
|
||||||
if (!Array.isArray(private_keys))
|
|
||||||
private_keys = [private_keys];
|
|
||||||
tx_fetch_for_editing(tx_hex).then(tx => {
|
|
||||||
parseTransaction(tx).then(tx_parsed => {
|
|
||||||
if (tx_parsed.fee >= new_fee)
|
|
||||||
return reject("Fees can only be increased");
|
|
||||||
|
|
||||||
//editable addresses in output values (for fee increase)
|
|
||||||
var edit_output_address = new Set();
|
|
||||||
if (change_only === true) //allow only change values (ie, sender address) to be edited to inc fee
|
|
||||||
tx_parsed.inputs.forEach(inp => edit_output_address.add(inp.address));
|
|
||||||
else if (change_only === false) //allow all output values to be edited
|
|
||||||
tx_parsed.outputs.forEach(out => edit_output_address.add(out.address));
|
|
||||||
else if (typeof change_only == 'string') // allow only given receiver id output to be edited
|
|
||||||
edit_output_address.add(change_only);
|
|
||||||
else if (Array.isArray(change_only)) //allow only given set of receiver id outputs to be edited
|
|
||||||
change_only.forEach(id => edit_output_address.add(id));
|
|
||||||
|
|
||||||
//edit output values to increase fee
|
|
||||||
let inc_fee = util.BTC_to_Sat(new_fee - tx_parsed.fee);
|
|
||||||
if (inc_fee < MIN_FEE_UPDATE)
|
|
||||||
return reject(`Insufficient additional fee. Minimum increment: ${MIN_FEE_UPDATE}`);
|
|
||||||
for (let i = tx.outs.length - 1; i >= 0 && inc_fee > 0; i--) //reduce in reverse order
|
|
||||||
if (edit_output_address.has(tx_parsed.outputs[i].address)) {
|
|
||||||
let current_value = tx.outs[i].value;
|
|
||||||
if (current_value instanceof BigInteger) //convert BigInteger class to inv value
|
|
||||||
current_value = current_value.intValue();
|
|
||||||
//edit the value as required
|
|
||||||
if (current_value > inc_fee) {
|
|
||||||
tx.outs[i].value = current_value - inc_fee;
|
|
||||||
inc_fee = 0;
|
|
||||||
} else {
|
|
||||||
inc_fee -= current_value;
|
|
||||||
tx.outs[i].value = 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if (inc_fee > 0) {
|
|
||||||
let max_possible_fee = util.BTC_to_Sat(new_fee) - inc_fee; //in satoshi
|
|
||||||
return reject(`Insufficient output values to increase fee. Maximum fee possible: ${util.Sat_to_BTC(max_possible_fee)}`);
|
|
||||||
}
|
|
||||||
tx.outs = tx.outs.filter(o => o.value >= DUST_AMT); //remove all output with value less than DUST amount
|
|
||||||
|
|
||||||
//remove existing signatures and reset the scripts
|
|
||||||
let wif_keys = [];
|
|
||||||
for (let i in tx.ins) {
|
|
||||||
var addr = tx_parsed.inputs[i].address,
|
|
||||||
value = util.BTC_to_Sat(tx_parsed.inputs[i].value);
|
|
||||||
let addr_decode = coinjs.addressDecode(addr);
|
|
||||||
//find the correct key for addr
|
|
||||||
var privKey = private_keys.find(pk => verifyKey(addr, pk));
|
|
||||||
if (!privKey)
|
|
||||||
return reject(`Private key missing for ${addr}`);
|
|
||||||
//find redeemScript (if any)
|
|
||||||
const rs = _redeemScript(addr, privKey);
|
|
||||||
rs === false ? wif_keys.unshift(privKey) : wif_keys.push(privKey); //sorting private-keys (wif)
|
|
||||||
//reset the script for re-signing
|
|
||||||
var script;
|
|
||||||
if (!rs || !rs.length) {
|
|
||||||
//legacy script (derive from address)
|
|
||||||
let s = coinjs.script();
|
|
||||||
s.writeOp(118); //OP_DUP
|
|
||||||
s.writeOp(169); //OP_HASH160
|
|
||||||
s.writeBytes(addr_decode.bytes);
|
|
||||||
s.writeOp(136); //OP_EQUALVERIFY
|
|
||||||
s.writeOp(172); //OP_CHECKSIG
|
|
||||||
script = Crypto.util.bytesToHex(s.buffer);
|
|
||||||
} else if (((rs.match(/^00/) && rs.length == 44)) || (rs.length == 40 && rs.match(/^[a-f0-9]+$/gi)) || addr_decode.type === 'multisigBech32') {
|
|
||||||
//redeemScript for segwit/bech32 and multisig (bech32)
|
|
||||||
let s = coinjs.script();
|
|
||||||
s.writeBytes(Crypto.util.hexToBytes(rs));
|
|
||||||
s.writeOp(0);
|
|
||||||
s.writeBytes(coinjs.numToBytes(value.toFixed(0), 8));
|
|
||||||
script = Crypto.util.bytesToHex(s.buffer);
|
|
||||||
} else //redeemScript for multisig (segwit)
|
|
||||||
script = rs;
|
|
||||||
tx.ins[i].script = coinjs.script(script);
|
|
||||||
}
|
|
||||||
tx.witness = false; //remove all witness signatures
|
|
||||||
console.debug("Unsigned:", tx.serialize());
|
|
||||||
//re-sign the transaction
|
|
||||||
new Set(wif_keys).forEach(key => tx.sign(key, 1 /*sighashtype*/)); //Sign the tx using private key WIF
|
|
||||||
resolve(tx.serialize());
|
|
||||||
}).catch(error => reject(error))
|
|
||||||
}).catch(error => reject(error))
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
btcOperator.sendTx = function (senders, privkeys, receivers, amounts, fee = null, options = {}) {
|
|
||||||
return new Promise((resolve, reject) => {
|
|
||||||
createSignedTx(senders, privkeys, receivers, amounts, fee, options).then(result => {
|
|
||||||
debugger;
|
|
||||||
broadcastTx(result.transaction.serialize())
|
|
||||||
.then(txid => resolve(txid))
|
|
||||||
.catch(error => reject(error));
|
|
||||||
}).catch(error => reject(error))
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
const createSignedTx = btcOperator.createSignedTx = function (senders, privkeys, receivers, amounts, fee = null, options = {}) {
|
|
||||||
return new Promise((resolve, reject) => {
|
|
||||||
try {
|
|
||||||
({
|
|
||||||
senders,
|
|
||||||
privkeys,
|
|
||||||
receivers,
|
|
||||||
amounts
|
|
||||||
} = validateTxParameters({
|
|
||||||
senders,
|
|
||||||
privkeys,
|
|
||||||
receivers,
|
|
||||||
amounts,
|
|
||||||
fee,
|
|
||||||
change_address: options.change_address
|
|
||||||
}));
|
|
||||||
} catch (e) {
|
|
||||||
return reject(e)
|
|
||||||
}
|
|
||||||
let redeemScripts = [],
|
|
||||||
wif_keys = [];
|
|
||||||
for (let i in senders) {
|
|
||||||
let rs = _redeemScript(senders[i], privkeys[i]); //get redeem-script (segwit/bech32)
|
|
||||||
redeemScripts.push(rs);
|
|
||||||
rs === false ? wif_keys.unshift(privkeys[i]) : wif_keys.push(privkeys[i]); //sorting private-keys (wif)
|
|
||||||
}
|
|
||||||
if (redeemScripts.includes(null)) //TODO: segwit
|
|
||||||
return reject("Unable to get redeem-script");
|
|
||||||
//create transaction
|
|
||||||
createTransaction(senders, redeemScripts, receivers, amounts, fee, options.change_address || senders[0], options.fee_from_receiver).then(result => {
|
|
||||||
let tx = result.transaction;
|
|
||||||
console.debug("Unsigned:", tx.serialize());
|
|
||||||
new Set(wif_keys).forEach(key => tx.sign(key, 1 /*sighashtype*/)); //Sign the tx using private key WIF
|
|
||||||
console.debug("Signed:", tx.serialize());
|
|
||||||
resolve(result);
|
|
||||||
}).catch(error => reject(error));
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
btcOperator.createTx = function (senders, receivers, amounts, fee = null, options = {}) {
|
|
||||||
return new Promise((resolve, reject) => {
|
|
||||||
try {
|
|
||||||
({
|
|
||||||
senders,
|
|
||||||
receivers,
|
|
||||||
amounts
|
|
||||||
} = validateTxParameters({
|
|
||||||
senders,
|
|
||||||
receivers,
|
|
||||||
amounts,
|
|
||||||
fee,
|
|
||||||
change_address: options.change_address
|
|
||||||
}));
|
|
||||||
} catch (e) {
|
|
||||||
return reject(e)
|
|
||||||
}
|
|
||||||
let redeemScripts = senders.map(id => _redeemScript(id));
|
|
||||||
if (redeemScripts.includes(null)) //TODO: segwit
|
|
||||||
return reject("Unable to get redeem-script");
|
|
||||||
//create transaction
|
|
||||||
createTransaction(senders, redeemScripts, receivers, amounts, fee, options.change_address || senders[0], options.fee_from_receiver).then(result => {
|
|
||||||
result.tx_hex = result.transaction.serialize();
|
|
||||||
delete result.transaction;
|
|
||||||
resolve(result);
|
|
||||||
}).catch(error => reject(error))
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
btcOperator.createMultiSigTx = function (sender, redeemScript, receivers, amounts, fee = null, options = {}) {
|
|
||||||
return new Promise((resolve, reject) => {
|
|
||||||
//validate tx parameters
|
|
||||||
let addr_type = validateAddress(sender);
|
|
||||||
if (!(["multisig", "multisigBech32"].includes(addr_type)))
|
|
||||||
return reject("Invalid sender (multisig):" + sender);
|
|
||||||
else {
|
|
||||||
let script = coinjs.script();
|
|
||||||
let decode = (addr_type == "multisig") ?
|
|
||||||
script.decodeRedeemScript(redeemScript) :
|
|
||||||
script.decodeRedeemScriptBech32(redeemScript);
|
|
||||||
if (!decode || decode.address !== sender)
|
|
||||||
return reject("Invalid redeem-script");
|
|
||||||
}
|
|
||||||
try {
|
|
||||||
({
|
|
||||||
receivers,
|
|
||||||
amounts
|
|
||||||
} = validateTxParameters({
|
|
||||||
receivers,
|
|
||||||
amounts,
|
|
||||||
fee,
|
|
||||||
change_address: options.change_address
|
|
||||||
}));
|
|
||||||
} catch (e) {
|
|
||||||
return reject(e)
|
|
||||||
}
|
|
||||||
//create transaction
|
|
||||||
createTransaction([sender], [redeemScript], receivers, amounts, fee, options.change_address || sender, options.fee_from_receiver).then(result => {
|
|
||||||
result.tx_hex = result.transaction.serialize();
|
|
||||||
delete result.transaction;
|
|
||||||
resolve(result);
|
|
||||||
}).catch(error => reject(error))
|
|
||||||
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
function deserializeTx(tx) {
|
|
||||||
if (typeof tx === 'string' || Array.isArray(tx)) {
|
|
||||||
try {
|
|
||||||
tx = coinjs.transaction().deserialize(tx);
|
|
||||||
} catch {
|
|
||||||
throw "Invalid transaction hex";
|
|
||||||
}
|
|
||||||
} else if (typeof tx !== 'object' || typeof tx.sign !== 'function')
|
|
||||||
throw "Invalid transaction object";
|
|
||||||
return tx;
|
|
||||||
}
|
|
||||||
|
|
||||||
btcOperator.signTx = function (tx, privkeys, sighashtype = 1) {
|
|
||||||
tx = deserializeTx(tx);
|
|
||||||
if (!Array.isArray(privkeys))
|
|
||||||
privkeys = [privkeys];
|
|
||||||
for (let i in privkeys)
|
|
||||||
if (privkeys[i].length === 64)
|
|
||||||
privkeys[i] = coinjs.privkey2wif(privkeys[i]);
|
|
||||||
new Set(privkeys).forEach(key => tx.sign(key, sighashtype)); //Sign the tx using private key WIF
|
|
||||||
return tx.serialize();
|
|
||||||
}
|
|
||||||
|
|
||||||
const checkSigned = btcOperator.checkSigned = function (tx, bool = true) {
|
|
||||||
tx = deserializeTx(tx);
|
|
||||||
let n = [];
|
|
||||||
for (let i in tx.ins) {
|
|
||||||
var s = tx.extractScriptKey(i);
|
|
||||||
if (s['type'] !== 'multisig' && s['type'] !== 'multisig_bech32')
|
|
||||||
n.push(s.signed == 'true' || (tx.witness[i] && tx.witness[i].length == 2))
|
|
||||||
else {
|
|
||||||
var rs = coinjs.script().decodeRedeemScript(s.script); //will work for bech32 too, as only address is diff
|
|
||||||
let x = {
|
|
||||||
s: s['signatures'],
|
|
||||||
r: rs['signaturesRequired'],
|
|
||||||
t: rs['pubkeys'].length
|
|
||||||
};
|
|
||||||
if (x.r > x.t)
|
|
||||||
throw "signaturesRequired is more than publicKeys";
|
|
||||||
else if (x.s < x.r)
|
|
||||||
n.push(x);
|
|
||||||
else
|
|
||||||
n.push(true);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return bool ? !(n.filter(x => x !== true).length) : n;
|
|
||||||
}
|
|
||||||
|
|
||||||
btcOperator.checkIfSameTx = function (tx1, tx2) {
|
|
||||||
tx1 = deserializeTx(tx1);
|
|
||||||
tx2 = deserializeTx(tx2);
|
|
||||||
//compare input and output length
|
|
||||||
if (tx1.ins.length !== tx2.ins.length || tx1.outs.length !== tx2.outs.length)
|
|
||||||
return false;
|
|
||||||
//compare inputs
|
|
||||||
for (let i = 0; i < tx1.ins.length; i++)
|
|
||||||
if (tx1.ins[i].outpoint.hash !== tx2.ins[i].outpoint.hash || tx1.ins[i].outpoint.index !== tx2.ins[i].outpoint.index)
|
|
||||||
return false;
|
|
||||||
//compare outputs
|
|
||||||
for (let i = 0; i < tx1.outs.length; i++)
|
|
||||||
if (tx1.outs[i].value !== tx2.outs[i].value || Crypto.util.bytesToHex(tx1.outs[i].script.buffer) !== Crypto.util.bytesToHex(tx2.outs[i].script.buffer))
|
|
||||||
return false;
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
const getTxOutput = (txid, i) => new Promise((resolve, reject) => {
|
|
||||||
fetch_api(`rawtx/${txid}`)
|
|
||||||
.then(result => resolve(result.out[i]))
|
|
||||||
.catch(error => reject(error))
|
|
||||||
});
|
|
||||||
|
|
||||||
const parseTransaction = btcOperator.parseTransaction = function (tx) {
|
|
||||||
return new Promise((resolve, reject) => {
|
|
||||||
tx = deserializeTx(tx);
|
|
||||||
let result = {};
|
|
||||||
let promises = [];
|
|
||||||
//Parse Inputs
|
|
||||||
for (let i = 0; i < tx.ins.length; i++)
|
|
||||||
promises.push(getTxOutput(tx.ins[i].outpoint.hash, tx.ins[i].outpoint.index));
|
|
||||||
Promise.all(promises).then(inputs => {
|
|
||||||
result.inputs = inputs.map(inp => Object({
|
|
||||||
address: inp.addr,
|
|
||||||
value: util.Sat_to_BTC(inp.value)
|
|
||||||
}));
|
|
||||||
let signed = checkSigned(tx, false);
|
|
||||||
result.inputs.forEach((inp, i) => inp.signed = signed[i]);
|
|
||||||
//Parse Outputs
|
|
||||||
result.outputs = tx.outs.map(out => {
|
|
||||||
var address;
|
|
||||||
switch (out.script.chunks[0]) {
|
|
||||||
case 0: //bech32, multisig-bech32
|
|
||||||
address = util.encodeBech32(Crypto.util.bytesToHex(out.script.chunks[1]), coinjs.bech32.version, coinjs.bech32.hrp);
|
|
||||||
break;
|
|
||||||
case 169: //segwit, multisig-segwit
|
|
||||||
address = util.encodeLegacy(Crypto.util.bytesToHex(out.script.chunks[1]), coinjs.multisig);
|
|
||||||
break;
|
|
||||||
case 118: //legacy
|
|
||||||
address = util.encodeLegacy(Crypto.util.bytesToHex(out.script.chunks[2]), coinjs.pub);
|
|
||||||
}
|
|
||||||
return {
|
|
||||||
address,
|
|
||||||
value: util.Sat_to_BTC(out.value)
|
|
||||||
}
|
|
||||||
});
|
|
||||||
//Parse Totals
|
|
||||||
result.total_input = parseFloat(result.inputs.reduce((a, inp) => a += inp.value, 0).toFixed(8));
|
|
||||||
result.total_output = parseFloat(result.outputs.reduce((a, out) => a += out.value, 0).toFixed(8));
|
|
||||||
result.fee = parseFloat((result.total_input - result.total_output).toFixed(8));
|
|
||||||
resolve(result);
|
|
||||||
}).catch(error => reject(error))
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
btcOperator.transactionID = function (tx) {
|
|
||||||
tx = deserializeTx(tx);
|
|
||||||
let clone = coinjs.clone(tx);
|
|
||||||
clone.witness = null;
|
|
||||||
let raw_bytes = Crypto.util.hexToBytes(clone.serialize());
|
|
||||||
let txid = Crypto.SHA256(Crypto.SHA256(raw_bytes, { asBytes: true }), { asBytes: true }).reverse();
|
|
||||||
return Crypto.util.bytesToHex(txid);
|
|
||||||
}
|
|
||||||
|
|
||||||
const getLatestBlock = btcOperator.getLatestBlock = () => new Promise((resolve, reject) => {
|
|
||||||
fetch_api(`q/getblockcount`)
|
|
||||||
.then(result => resolve(result))
|
|
||||||
.catch(error => reject(error))
|
|
||||||
})
|
|
||||||
|
|
||||||
const getTx = btcOperator.getTx = txid => new Promise((resolve, reject) => {
|
|
||||||
fetch_api(`rawtx/${txid}`).then(result => {
|
|
||||||
getLatestBlock().then(latest_block => resolve({
|
|
||||||
block: result.block_height,
|
|
||||||
txid: result.hash,
|
|
||||||
time: result.time * 1000,
|
|
||||||
confirmations: result.block_height === null ? 0 : latest_block - result.block_height, //calculate confirmations using latest block number as api doesnt relay it
|
|
||||||
size: result.size,
|
|
||||||
fee: util.Sat_to_BTC(result.fee),
|
|
||||||
inputs: result.inputs.map(i => Object({ address: i.prev_out.addr, value: util.Sat_to_BTC(i.prev_out.value) })),
|
|
||||||
total_input_value: util.Sat_to_BTC(result.inputs.reduce((a, i) => a + i.prev_out.value, 0)),
|
|
||||||
outputs: result.out.map(o => Object({ address: o.addr, value: util.Sat_to_BTC(o.value) })),
|
|
||||||
total_output_value: util.Sat_to_BTC(result.out.reduce((a, o) => a += o.value, 0)),
|
|
||||||
}))
|
|
||||||
}).catch(error => reject(error))
|
|
||||||
});
|
|
||||||
|
|
||||||
getTx.hex = txid => new Promise((resolve, reject) => {
|
|
||||||
fetch_api(`rawtx/${txid}?format=hex`, false)
|
|
||||||
.then(result => resolve(result))
|
|
||||||
.catch(error => reject(error))
|
|
||||||
})
|
|
||||||
|
|
||||||
btcOperator.getAddressData = address => new Promise((resolve, reject) => {
|
|
||||||
fetch_api(`rawaddr/${address}`).then(data => {
|
|
||||||
let details = {};
|
|
||||||
details.balance = util.Sat_to_BTC(data.final_balance);
|
|
||||||
details.address = data.address;
|
|
||||||
details.txs = data.txs.map(tx => {
|
|
||||||
let d = {
|
|
||||||
txid: tx.hash,
|
|
||||||
time: tx.time * 1000, //s to ms
|
|
||||||
block: tx.block_height,
|
|
||||||
}
|
|
||||||
//sender list
|
|
||||||
d.tx_senders = {};
|
|
||||||
tx.inputs.forEach(i => {
|
|
||||||
if (i.prev_out.addr in d.tx_senders)
|
|
||||||
d.tx_senders[i.prev_out.addr] += i.prev_out.value;
|
|
||||||
else d.tx_senders[i.prev_out.addr] = i.prev_out.value;
|
|
||||||
});
|
|
||||||
d.tx_input_value = 0;
|
|
||||||
for (let s in d.tx_senders) {
|
|
||||||
let val = d.tx_senders[s];
|
|
||||||
d.tx_senders[s] = util.Sat_to_BTC(val);
|
|
||||||
d.tx_input_value += val;
|
|
||||||
}
|
|
||||||
d.tx_input_value = util.Sat_to_BTC(d.tx_input_value);
|
|
||||||
//receiver list
|
|
||||||
d.tx_receivers = {};
|
|
||||||
tx.out.forEach(o => {
|
|
||||||
if (o.addr in d.tx_receivers)
|
|
||||||
d.tx_receivers[o.addr] += o.value;
|
|
||||||
else d.tx_receivers[o.addr] = o.value;
|
|
||||||
});
|
|
||||||
d.tx_output_value = 0;
|
|
||||||
for (let r in d.tx_receivers) {
|
|
||||||
let val = d.tx_receivers[r];
|
|
||||||
d.tx_receivers[r] = util.Sat_to_BTC(val);
|
|
||||||
d.tx_output_value += val;
|
|
||||||
}
|
|
||||||
d.tx_output_value = util.Sat_to_BTC(d.tx_output_value);
|
|
||||||
d.tx_fee = util.Sat_to_BTC(tx.fee);
|
|
||||||
//tx type
|
|
||||||
if (tx.result > 0) { //net > 0, balance inc => type=in
|
|
||||||
d.type = "in";
|
|
||||||
d.amount = util.Sat_to_BTC(tx.result);
|
|
||||||
d.sender = Object.keys(d.tx_senders).filter(s => s !== address);
|
|
||||||
} else if (Object.keys(d.tx_receivers).some(r => r !== address)) { //net < 0, balance dec & receiver present => type=out
|
|
||||||
d.type = "out";
|
|
||||||
d.amount = util.Sat_to_BTC(tx.result * -1);
|
|
||||||
d.receiver = Object.keys(d.tx_receivers).filter(r => r !== address);
|
|
||||||
d.fee = d.tx_fee;
|
|
||||||
} else { //net < 0 (fee) & no other id in receiver list => type=self
|
|
||||||
d.type = "self";
|
|
||||||
d.amount = d.tx_receivers[address];
|
|
||||||
d.address = address
|
|
||||||
}
|
|
||||||
return d;
|
|
||||||
})
|
|
||||||
resolve(details);
|
|
||||||
}).catch(error => reject(error))
|
|
||||||
});
|
|
||||||
|
|
||||||
btcOperator.getBlock = block => new Promise((resolve, reject) => {
|
|
||||||
fetch_api(`rawblock/${block}`).then(result => resolve({
|
|
||||||
height: result.height,
|
|
||||||
hash: result.hash,
|
|
||||||
merkle_root: result.mrkl_root,
|
|
||||||
prev_block: result.prev_block,
|
|
||||||
next_block: result.next_block[0],
|
|
||||||
size: result.size,
|
|
||||||
time: result.time * 1000, //s to ms
|
|
||||||
txs: result.tx.map(t => Object({
|
|
||||||
fee: t.fee,
|
|
||||||
size: t.size,
|
|
||||||
inputs: t.inputs.map(i => Object({ address: i.prev_out.addr, value: util.Sat_to_BTC(i.prev_out.value) })),
|
|
||||||
total_input_value: util.Sat_to_BTC(t.inputs.reduce((a, i) => a + i.prev_out.value, 0)),
|
|
||||||
outputs: t.out.map(o => Object({ address: o.addr, value: util.Sat_to_BTC(o.value) })),
|
|
||||||
total_output_value: util.Sat_to_BTC(t.out.reduce((a, o) => a += o.value, 0)),
|
|
||||||
}))
|
|
||||||
|
|
||||||
})).catch(error => reject(error))
|
|
||||||
});
|
|
||||||
|
|
||||||
})('object' === typeof module ? module.exports : window.btcOperator = {});
|
|
||||||
File diff suppressed because it is too large
Load Diff
@ -1,530 +0,0 @@
|
|||||||
(function (EXPORTS) { //floCrypto v2.3.6a
|
|
||||||
/* FLO Crypto Operators */
|
|
||||||
'use strict';
|
|
||||||
const floCrypto = EXPORTS;
|
|
||||||
|
|
||||||
const p = BigInteger("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F", 16);
|
|
||||||
const ecparams = EllipticCurve.getSECCurveByName("secp256k1");
|
|
||||||
const ascii_alternatives = `‘ '\n’ '\n“ "\n” "\n– --\n— ---\n≥ >=\n≤ <=\n≠ !=\n× *\n÷ /\n← <-\n→ ->\n↔ <->\n⇒ =>\n⇐ <=\n⇔ <=>`;
|
|
||||||
const exponent1 = () => p.add(BigInteger.ONE).divide(BigInteger("4"));
|
|
||||||
coinjs.compressed = true; //defaulting coinjs compressed to true;
|
|
||||||
|
|
||||||
function calculateY(x) {
|
|
||||||
let exp = exponent1();
|
|
||||||
// x is x value of public key in BigInteger format without 02 or 03 or 04 prefix
|
|
||||||
return x.modPow(BigInteger("3"), p).add(BigInteger("7")).mod(p).modPow(exp, p)
|
|
||||||
}
|
|
||||||
|
|
||||||
function getUncompressedPublicKey(compressedPublicKey) {
|
|
||||||
// Fetch x from compressedPublicKey
|
|
||||||
let pubKeyBytes = Crypto.util.hexToBytes(compressedPublicKey);
|
|
||||||
const prefix = pubKeyBytes.shift() // remove prefix
|
|
||||||
let prefix_modulus = prefix % 2;
|
|
||||||
pubKeyBytes.unshift(0) // add prefix 0
|
|
||||||
let x = new BigInteger(pubKeyBytes)
|
|
||||||
let xDecimalValue = x.toString()
|
|
||||||
// Fetch y
|
|
||||||
let y = calculateY(x);
|
|
||||||
let yDecimalValue = y.toString();
|
|
||||||
// verify y value
|
|
||||||
let resultBigInt = y.mod(BigInteger("2"));
|
|
||||||
let check = resultBigInt.toString() % 2;
|
|
||||||
if (prefix_modulus !== check)
|
|
||||||
yDecimalValue = y.negate().mod(p).toString();
|
|
||||||
return {
|
|
||||||
x: xDecimalValue,
|
|
||||||
y: yDecimalValue
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
function getSenderPublicKeyString() {
|
|
||||||
let privateKey = ellipticCurveEncryption.senderRandom();
|
|
||||||
var senderPublicKeyString = ellipticCurveEncryption.senderPublicString(privateKey);
|
|
||||||
return {
|
|
||||||
privateKey: privateKey,
|
|
||||||
senderPublicKeyString: senderPublicKeyString
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
function deriveSharedKeySender(receiverPublicKeyHex, senderPrivateKey) {
|
|
||||||
let receiverPublicKeyString = getUncompressedPublicKey(receiverPublicKeyHex);
|
|
||||||
var senderDerivedKey = ellipticCurveEncryption.senderSharedKeyDerivation(
|
|
||||||
receiverPublicKeyString.x, receiverPublicKeyString.y, senderPrivateKey);
|
|
||||||
return senderDerivedKey;
|
|
||||||
}
|
|
||||||
|
|
||||||
function deriveSharedKeyReceiver(senderPublicKeyString, receiverPrivateKey) {
|
|
||||||
return ellipticCurveEncryption.receiverSharedKeyDerivation(
|
|
||||||
senderPublicKeyString.XValuePublicString, senderPublicKeyString.YValuePublicString, receiverPrivateKey);
|
|
||||||
}
|
|
||||||
|
|
||||||
function getReceiverPublicKeyString(privateKey) {
|
|
||||||
return ellipticCurveEncryption.receiverPublicString(privateKey);
|
|
||||||
}
|
|
||||||
|
|
||||||
function wifToDecimal(pk_wif, isPubKeyCompressed = false) {
|
|
||||||
let pk = Bitcoin.Base58.decode(pk_wif)
|
|
||||||
pk.shift()
|
|
||||||
pk.splice(-4, 4)
|
|
||||||
//If the private key corresponded to a compressed public key, also drop the last byte (it should be 0x01).
|
|
||||||
if (isPubKeyCompressed == true) pk.pop()
|
|
||||||
pk.unshift(0)
|
|
||||||
let privateKeyDecimal = BigInteger(pk).toString()
|
|
||||||
let privateKeyHex = Crypto.util.bytesToHex(pk)
|
|
||||||
return {
|
|
||||||
privateKeyDecimal: privateKeyDecimal,
|
|
||||||
privateKeyHex: privateKeyHex
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
//generate a random Interger within range
|
|
||||||
floCrypto.randInt = function (min, max) {
|
|
||||||
min = Math.ceil(min);
|
|
||||||
max = Math.floor(max);
|
|
||||||
return Math.floor(securedMathRandom() * (max - min + 1)) + min;
|
|
||||||
}
|
|
||||||
|
|
||||||
//generate a random String within length (options : alphaNumeric chars only)
|
|
||||||
floCrypto.randString = function (length, alphaNumeric = true) {
|
|
||||||
var result = '';
|
|
||||||
var characters = alphaNumeric ? 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789' :
|
|
||||||
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_+-./*?@#&$<>=[]{}():';
|
|
||||||
for (var i = 0; i < length; i++)
|
|
||||||
result += characters.charAt(Math.floor(securedMathRandom() * characters.length));
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
//Encrypt Data using public-key
|
|
||||||
floCrypto.encryptData = function (data, receiverPublicKeyHex) {
|
|
||||||
var senderECKeyData = getSenderPublicKeyString();
|
|
||||||
var senderDerivedKey = deriveSharedKeySender(receiverPublicKeyHex, senderECKeyData.privateKey);
|
|
||||||
let senderKey = senderDerivedKey.XValue + senderDerivedKey.YValue;
|
|
||||||
let secret = Crypto.AES.encrypt(data, senderKey);
|
|
||||||
return {
|
|
||||||
secret: secret,
|
|
||||||
senderPublicKeyString: senderECKeyData.senderPublicKeyString
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
//Decrypt Data using private-key
|
|
||||||
floCrypto.decryptData = function (data, privateKeyHex) {
|
|
||||||
var receiverECKeyData = {};
|
|
||||||
if (typeof privateKeyHex !== "string") throw new Error("No private key found.");
|
|
||||||
let privateKey = wifToDecimal(privateKeyHex, true);
|
|
||||||
if (typeof privateKey.privateKeyDecimal !== "string") throw new Error("Failed to detremine your private key.");
|
|
||||||
receiverECKeyData.privateKey = privateKey.privateKeyDecimal;
|
|
||||||
var receiverDerivedKey = deriveSharedKeyReceiver(data.senderPublicKeyString, receiverECKeyData.privateKey);
|
|
||||||
let receiverKey = receiverDerivedKey.XValue + receiverDerivedKey.YValue;
|
|
||||||
let decryptMsg = Crypto.AES.decrypt(data.secret, receiverKey);
|
|
||||||
return decryptMsg;
|
|
||||||
}
|
|
||||||
|
|
||||||
//Sign data using private-key
|
|
||||||
floCrypto.signData = function (data, privateKeyHex) {
|
|
||||||
var key = new Bitcoin.ECKey(privateKeyHex);
|
|
||||||
var messageHash = Crypto.SHA256(data);
|
|
||||||
var messageSign = Bitcoin.ECDSA.sign(messageHash, key.priv);
|
|
||||||
var sighex = Crypto.util.bytesToHex(messageSign);
|
|
||||||
return sighex;
|
|
||||||
}
|
|
||||||
|
|
||||||
//Verify signatue of the data using public-key
|
|
||||||
floCrypto.verifySign = function (data, signatureHex, publicKeyHex) {
|
|
||||||
var msgHash = Crypto.SHA256(data);
|
|
||||||
var sigBytes = Crypto.util.hexToBytes(signatureHex);
|
|
||||||
var publicKeyPoint = ecparams.getCurve().decodePointHex(publicKeyHex);
|
|
||||||
var verify = Bitcoin.ECDSA.verify(msgHash, sigBytes, publicKeyPoint);
|
|
||||||
return verify;
|
|
||||||
}
|
|
||||||
|
|
||||||
//Generates a new flo ID and returns private-key, public-key and floID
|
|
||||||
const generateNewID = floCrypto.generateNewID = function () {
|
|
||||||
var key = new Bitcoin.ECKey(false);
|
|
||||||
key.setCompressed(true);
|
|
||||||
return {
|
|
||||||
floID: key.getBitcoinAddress(),
|
|
||||||
pubKey: key.getPubKeyHex(),
|
|
||||||
privKey: key.getBitcoinWalletImportFormat()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
Object.defineProperties(floCrypto, {
|
|
||||||
newID: {
|
|
||||||
get: () => generateNewID()
|
|
||||||
},
|
|
||||||
hashID: {
|
|
||||||
value: (str) => {
|
|
||||||
let bytes = ripemd160(Crypto.SHA256(str, { asBytes: true }), { asBytes: true });
|
|
||||||
bytes.unshift(bitjs.pub);
|
|
||||||
var hash = Crypto.SHA256(Crypto.SHA256(bytes, {
|
|
||||||
asBytes: true
|
|
||||||
}), {
|
|
||||||
asBytes: true
|
|
||||||
});
|
|
||||||
var checksum = hash.slice(0, 4);
|
|
||||||
return bitjs.Base58.encode(bytes.concat(checksum));
|
|
||||||
}
|
|
||||||
},
|
|
||||||
tmpID: {
|
|
||||||
get: () => {
|
|
||||||
let bytes = Crypto.util.randomBytes(20);
|
|
||||||
bytes.unshift(bitjs.pub);
|
|
||||||
var hash = Crypto.SHA256(Crypto.SHA256(bytes, {
|
|
||||||
asBytes: true
|
|
||||||
}), {
|
|
||||||
asBytes: true
|
|
||||||
});
|
|
||||||
var checksum = hash.slice(0, 4);
|
|
||||||
return bitjs.Base58.encode(bytes.concat(checksum));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
});
|
|
||||||
|
|
||||||
//Returns public-key from private-key
|
|
||||||
floCrypto.getPubKeyHex = function (privateKeyHex) {
|
|
||||||
if (!privateKeyHex)
|
|
||||||
return null;
|
|
||||||
var key = new Bitcoin.ECKey(privateKeyHex);
|
|
||||||
if (key.priv == null)
|
|
||||||
return null;
|
|
||||||
key.setCompressed(true);
|
|
||||||
return key.getPubKeyHex();
|
|
||||||
}
|
|
||||||
|
|
||||||
//Returns flo-ID from public-key or private-key
|
|
||||||
floCrypto.getFloID = function (keyHex) {
|
|
||||||
if (!keyHex)
|
|
||||||
return null;
|
|
||||||
try {
|
|
||||||
var key = new Bitcoin.ECKey(keyHex);
|
|
||||||
if (key.priv == null)
|
|
||||||
key.setPub(keyHex);
|
|
||||||
return key.getBitcoinAddress();
|
|
||||||
} catch {
|
|
||||||
return null;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
floCrypto.getAddress = function (privateKeyHex, strict = false) {
|
|
||||||
if (!privateKeyHex)
|
|
||||||
return;
|
|
||||||
var key = new Bitcoin.ECKey(privateKeyHex);
|
|
||||||
if (key.priv == null)
|
|
||||||
return null;
|
|
||||||
key.setCompressed(true);
|
|
||||||
let pubKey = key.getPubKeyHex(),
|
|
||||||
version = bitjs.Base58.decode(privateKeyHex)[0];
|
|
||||||
switch (version) {
|
|
||||||
case coinjs.priv: //BTC
|
|
||||||
return coinjs.bech32Address(pubKey).address;
|
|
||||||
case bitjs.priv: //FLO
|
|
||||||
return bitjs.pubkey2address(pubKey);
|
|
||||||
default:
|
|
||||||
return strict ? false : bitjs.pubkey2address(pubKey); //default to FLO address (if strict=false)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
//Verify the private-key for the given public-key or flo-ID
|
|
||||||
floCrypto.verifyPrivKey = function (privateKeyHex, pubKey_floID, isfloID = true) {
|
|
||||||
if (!privateKeyHex || !pubKey_floID)
|
|
||||||
return false;
|
|
||||||
try {
|
|
||||||
var key = new Bitcoin.ECKey(privateKeyHex);
|
|
||||||
if (key.priv == null)
|
|
||||||
return false;
|
|
||||||
key.setCompressed(true);
|
|
||||||
if (isfloID && pubKey_floID == key.getBitcoinAddress())
|
|
||||||
return true;
|
|
||||||
else if (!isfloID && pubKey_floID.toUpperCase() == key.getPubKeyHex().toUpperCase())
|
|
||||||
return true;
|
|
||||||
else
|
|
||||||
return false;
|
|
||||||
} catch {
|
|
||||||
return null;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
floCrypto.getMultisigAddress = function (publicKeyList, requiredSignatures) {
|
|
||||||
if (!Array.isArray(publicKeyList) || !publicKeyList.length)
|
|
||||||
return null;
|
|
||||||
if (!Number.isInteger(requiredSignatures) || requiredSignatures < 1 || requiredSignatures > publicKeyList.length)
|
|
||||||
return null;
|
|
||||||
try {
|
|
||||||
var multisig = bitjs.pubkeys2multisig(publicKeyList, requiredSignatures);
|
|
||||||
return multisig;
|
|
||||||
} catch {
|
|
||||||
return null;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
floCrypto.decodeRedeemScript = function (redeemScript) {
|
|
||||||
try {
|
|
||||||
var decoded = bitjs.transaction().decodeRedeemScript(redeemScript);
|
|
||||||
return decoded;
|
|
||||||
} catch {
|
|
||||||
return null;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
//Check if the given flo-id is valid or not
|
|
||||||
floCrypto.validateFloID = function (floID, regularOnly = false) {
|
|
||||||
if (!floID)
|
|
||||||
return false;
|
|
||||||
try {
|
|
||||||
let addr = new Bitcoin.Address(floID);
|
|
||||||
if (regularOnly && addr.version != Bitcoin.Address.standardVersion)
|
|
||||||
return false;
|
|
||||||
return true;
|
|
||||||
} catch {
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
//Check if the given address (any blockchain) is valid or not
|
|
||||||
floCrypto.validateAddr = function (address, std = true, bech = true) {
|
|
||||||
let raw = decodeAddress(address);
|
|
||||||
if (!raw)
|
|
||||||
return false;
|
|
||||||
if (typeof raw.version !== 'undefined') { //legacy or segwit
|
|
||||||
if (std == false)
|
|
||||||
return false;
|
|
||||||
else if (std === true || (!Array.isArray(std) && std === raw.version) || (Array.isArray(std) && std.includes(raw.version)))
|
|
||||||
return true;
|
|
||||||
else
|
|
||||||
return false;
|
|
||||||
} else if (typeof raw.bech_version !== 'undefined') { //bech32
|
|
||||||
if (bech === false)
|
|
||||||
return false;
|
|
||||||
else if (bech === true || (!Array.isArray(bech) && bech === raw.bech_version) || (Array.isArray(bech) && bech.includes(raw.bech_version)))
|
|
||||||
return true;
|
|
||||||
else
|
|
||||||
return false;
|
|
||||||
} else //unknown
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
//Check the public-key (or redeem-script) for the address (any blockchain)
|
|
||||||
floCrypto.verifyPubKey = function (pubKeyHex, address) {
|
|
||||||
let raw = decodeAddress(address);
|
|
||||||
if (!raw)
|
|
||||||
return;
|
|
||||||
let pub_hash = Crypto.util.bytesToHex(ripemd160(Crypto.SHA256(Crypto.util.hexToBytes(pubKeyHex), { asBytes: true })));
|
|
||||||
if (typeof raw.bech_version !== 'undefined' && raw.bytes.length == 32) //bech32-multisig
|
|
||||||
raw.hex = Crypto.util.bytesToHex(ripemd160(raw.bytes, { asBytes: true }));
|
|
||||||
return pub_hash === raw.hex;
|
|
||||||
}
|
|
||||||
|
|
||||||
//Convert the given address (any blockchain) to equivalent floID
|
|
||||||
floCrypto.toFloID = function (address, options = null) {
|
|
||||||
if (!address)
|
|
||||||
return;
|
|
||||||
let raw = decodeAddress(address);
|
|
||||||
if (!raw)
|
|
||||||
return;
|
|
||||||
else if (options) { //if (optional) version check is passed
|
|
||||||
if (typeof raw.version !== 'undefined' && (!options.std || !options.std.includes(raw.version)))
|
|
||||||
return;
|
|
||||||
if (typeof raw.bech_version !== 'undefined' && (!options.bech || !options.bech.includes(raw.bech_version)))
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
raw.bytes.unshift(bitjs.pub);
|
|
||||||
let hash = Crypto.SHA256(Crypto.SHA256(raw.bytes, {
|
|
||||||
asBytes: true
|
|
||||||
}), {
|
|
||||||
asBytes: true
|
|
||||||
});
|
|
||||||
return bitjs.Base58.encode(raw.bytes.concat(hash.slice(0, 4)));
|
|
||||||
}
|
|
||||||
|
|
||||||
//Convert raw address bytes to floID
|
|
||||||
floCrypto.rawToFloID = function (raw_bytes) {
|
|
||||||
if (typeof raw_bytes === 'string')
|
|
||||||
raw_bytes = Crypto.util.hexToBytes(raw_bytes);
|
|
||||||
if (raw_bytes.length != 20)
|
|
||||||
return null;
|
|
||||||
raw_bytes.unshift(bitjs.pub);
|
|
||||||
let hash = Crypto.SHA256(Crypto.SHA256(raw_bytes, {
|
|
||||||
asBytes: true
|
|
||||||
}), {
|
|
||||||
asBytes: true
|
|
||||||
});
|
|
||||||
return bitjs.Base58.encode(raw_bytes.concat(hash.slice(0, 4)));
|
|
||||||
}
|
|
||||||
|
|
||||||
//Convert the given multisig address (any blockchain) to equivalent multisig floID
|
|
||||||
floCrypto.toMultisigFloID = function (address, options = null) {
|
|
||||||
if (!address)
|
|
||||||
return;
|
|
||||||
let raw = decodeAddress(address);
|
|
||||||
if (!raw)
|
|
||||||
return;
|
|
||||||
else if (options) { //if (optional) version check is passed
|
|
||||||
if (typeof raw.version !== 'undefined' && (!options.std || !options.std.includes(raw.version)))
|
|
||||||
return;
|
|
||||||
if (typeof raw.bech_version !== 'undefined' && (!options.bech || !options.bech.includes(raw.bech_version)))
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
if (typeof raw.bech_version !== 'undefined') {
|
|
||||||
if (raw.bytes.length != 32) return; //multisig bech address have 32 bytes
|
|
||||||
//multisig-bech:hash=SHA256 whereas multisig:hash=r160(SHA265), thus ripemd160 the bytes from multisig-bech
|
|
||||||
raw.bytes = ripemd160(raw.bytes, {
|
|
||||||
asBytes: true
|
|
||||||
});
|
|
||||||
}
|
|
||||||
raw.bytes.unshift(bitjs.multisig);
|
|
||||||
let hash = Crypto.SHA256(Crypto.SHA256(raw.bytes, {
|
|
||||||
asBytes: true
|
|
||||||
}), {
|
|
||||||
asBytes: true
|
|
||||||
});
|
|
||||||
return bitjs.Base58.encode(raw.bytes.concat(hash.slice(0, 4)));
|
|
||||||
}
|
|
||||||
|
|
||||||
//Checks if the given addresses (any blockchain) are same (w.r.t keys)
|
|
||||||
floCrypto.isSameAddr = function (addr1, addr2) {
|
|
||||||
if (!addr1 || !addr2)
|
|
||||||
return;
|
|
||||||
let raw1 = decodeAddress(addr1),
|
|
||||||
raw2 = decodeAddress(addr2);
|
|
||||||
if (!raw1 || !raw2)
|
|
||||||
return false;
|
|
||||||
else {
|
|
||||||
if (typeof raw1.bech_version !== 'undefined' && raw1.bytes.length == 32) //bech32-multisig
|
|
||||||
raw1.hex = Crypto.util.bytesToHex(ripemd160(raw1.bytes, { asBytes: true }));
|
|
||||||
if (typeof raw2.bech_version !== 'undefined' && raw2.bytes.length == 32) //bech32-multisig
|
|
||||||
raw2.hex = Crypto.util.bytesToHex(ripemd160(raw2.bytes, { asBytes: true }));
|
|
||||||
return raw1.hex === raw2.hex;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
const decodeAddress = floCrypto.decodeAddr = function (address) {
|
|
||||||
if (!address)
|
|
||||||
return;
|
|
||||||
else if (address.length == 33 || address.length == 34) { //legacy encoding
|
|
||||||
let decode = bitjs.Base58.decode(address);
|
|
||||||
let bytes = decode.slice(0, decode.length - 4);
|
|
||||||
let checksum = decode.slice(decode.length - 4),
|
|
||||||
hash = Crypto.SHA256(Crypto.SHA256(bytes, {
|
|
||||||
asBytes: true
|
|
||||||
}), {
|
|
||||||
asBytes: true
|
|
||||||
});
|
|
||||||
return (hash[0] != checksum[0] || hash[1] != checksum[1] || hash[2] != checksum[2] || hash[3] != checksum[3]) ? null : {
|
|
||||||
version: bytes.shift(),
|
|
||||||
hex: Crypto.util.bytesToHex(bytes),
|
|
||||||
bytes
|
|
||||||
}
|
|
||||||
} else if (address.length == 42 || address.length == 62) { //bech encoding
|
|
||||||
let decode = coinjs.bech32_decode(address);
|
|
||||||
if (decode) {
|
|
||||||
let bytes = decode.data;
|
|
||||||
let bech_version = bytes.shift();
|
|
||||||
bytes = coinjs.bech32_convert(bytes, 5, 8, false);
|
|
||||||
return {
|
|
||||||
bech_version,
|
|
||||||
hrp: decode.hrp,
|
|
||||||
hex: Crypto.util.bytesToHex(bytes),
|
|
||||||
bytes
|
|
||||||
}
|
|
||||||
} else
|
|
||||||
return null;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
//Split the str using shamir's Secret and Returns the shares
|
|
||||||
floCrypto.createShamirsSecretShares = function (str, total_shares, threshold_limit) {
|
|
||||||
try {
|
|
||||||
if (str.length > 0) {
|
|
||||||
var strHex = shamirSecretShare.str2hex(str);
|
|
||||||
var shares = shamirSecretShare.share(strHex, total_shares, threshold_limit);
|
|
||||||
return shares;
|
|
||||||
}
|
|
||||||
return false;
|
|
||||||
} catch {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
//Returns the retrived secret by combining the shamirs shares
|
|
||||||
const retrieveShamirSecret = floCrypto.retrieveShamirSecret = function (sharesArray) {
|
|
||||||
try {
|
|
||||||
if (sharesArray.length > 0) {
|
|
||||||
var comb = shamirSecretShare.combine(sharesArray.slice(0, sharesArray.length));
|
|
||||||
comb = shamirSecretShare.hex2str(comb);
|
|
||||||
return comb;
|
|
||||||
}
|
|
||||||
return false;
|
|
||||||
} catch {
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
//Verifies the shares and str
|
|
||||||
floCrypto.verifyShamirsSecret = function (sharesArray, str) {
|
|
||||||
if (!str)
|
|
||||||
return null;
|
|
||||||
else if (retrieveShamirSecret(sharesArray) === str)
|
|
||||||
return true;
|
|
||||||
else
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
const validateASCII = floCrypto.validateASCII = function (string, bool = true) {
|
|
||||||
if (typeof string !== "string")
|
|
||||||
return null;
|
|
||||||
if (bool) {
|
|
||||||
let x;
|
|
||||||
for (let i = 0; i < string.length; i++) {
|
|
||||||
x = string.charCodeAt(i);
|
|
||||||
if (x < 32 || x > 127)
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
return true;
|
|
||||||
} else {
|
|
||||||
let x, invalids = {};
|
|
||||||
for (let i = 0; i < string.length; i++) {
|
|
||||||
x = string.charCodeAt(i);
|
|
||||||
if (x < 32 || x > 127)
|
|
||||||
if (x in invalids)
|
|
||||||
invalids[string[i]].push(i)
|
|
||||||
else
|
|
||||||
invalids[string[i]] = [i];
|
|
||||||
}
|
|
||||||
if (Object.keys(invalids).length)
|
|
||||||
return invalids;
|
|
||||||
else
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
floCrypto.convertToASCII = function (string, mode = 'soft-remove') {
|
|
||||||
let chars = validateASCII(string, false);
|
|
||||||
if (chars === true)
|
|
||||||
return string;
|
|
||||||
else if (chars === null)
|
|
||||||
return null;
|
|
||||||
let convertor, result = string,
|
|
||||||
refAlt = {};
|
|
||||||
ascii_alternatives.split('\n').forEach(a => refAlt[a[0]] = a.slice(2));
|
|
||||||
mode = mode.toLowerCase();
|
|
||||||
if (mode === "hard-unicode")
|
|
||||||
convertor = (c) => `\\u${('000' + c.charCodeAt().toString(16)).slice(-4)}`;
|
|
||||||
else if (mode === "soft-unicode")
|
|
||||||
convertor = (c) => refAlt[c] || `\\u${('000' + c.charCodeAt().toString(16)).slice(-4)}`;
|
|
||||||
else if (mode === "hard-remove")
|
|
||||||
convertor = c => "";
|
|
||||||
else if (mode === "soft-remove")
|
|
||||||
convertor = c => refAlt[c] || "";
|
|
||||||
else
|
|
||||||
return null;
|
|
||||||
for (let c in chars)
|
|
||||||
result = result.replaceAll(c, convertor(c));
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
floCrypto.revertUnicode = function (string) {
|
|
||||||
return string.replace(/\\u[\dA-F]{4}/gi,
|
|
||||||
m => String.fromCharCode(parseInt(m.replace(/\\u/g, ''), 16)));
|
|
||||||
}
|
|
||||||
|
|
||||||
})('object' === typeof module ? module.exports : window.floCrypto = {});
|
|
||||||
@ -1,7 +0,0 @@
|
|||||||
const floGlobals = {
|
|
||||||
blockchain: "FLO",
|
|
||||||
marketID: "FKAEdnPfjXLHSYwrXQu377ugN4tXU7VGdf",
|
|
||||||
currency: "BTC"
|
|
||||||
};
|
|
||||||
|
|
||||||
('object' === typeof module) ? module.exports = floGlobals : null;
|
|
||||||
@ -1,166 +0,0 @@
|
|||||||
(function (EXPORTS) { //floTokenAPI v1.0.4a
|
|
||||||
/* Token Operator to send/receive tokens via blockchain using API calls*/
|
|
||||||
'use strict';
|
|
||||||
const tokenAPI = EXPORTS;
|
|
||||||
|
|
||||||
const DEFAULT = {
|
|
||||||
apiURL: floGlobals.tokenURL || "https://ranchimallflo.duckdns.org/",
|
|
||||||
currency: floGlobals.currency || "rupee"
|
|
||||||
}
|
|
||||||
|
|
||||||
Object.defineProperties(tokenAPI, {
|
|
||||||
URL: {
|
|
||||||
get: () => DEFAULT.apiURL
|
|
||||||
},
|
|
||||||
currency: {
|
|
||||||
get: () => DEFAULT.currency,
|
|
||||||
set: currency => DEFAULT.currency = currency
|
|
||||||
}
|
|
||||||
});
|
|
||||||
|
|
||||||
if (floGlobals.currency) tokenAPI.currency = floGlobals.currency;
|
|
||||||
|
|
||||||
Object.defineProperties(floGlobals, {
|
|
||||||
currency: {
|
|
||||||
get: () => DEFAULT.currency,
|
|
||||||
set: currency => DEFAULT.currency = currency
|
|
||||||
}
|
|
||||||
});
|
|
||||||
|
|
||||||
const fetch_api = tokenAPI.fetch = function (apicall) {
|
|
||||||
return new Promise((resolve, reject) => {
|
|
||||||
console.debug(DEFAULT.apiURL + apicall);
|
|
||||||
fetch(DEFAULT.apiURL + apicall).then(response => {
|
|
||||||
if (response.ok)
|
|
||||||
response.json().then(data => resolve(data));
|
|
||||||
else
|
|
||||||
reject(response)
|
|
||||||
}).catch(error => reject(error))
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
const getBalance = tokenAPI.getBalance = function (floID, token = DEFAULT.currency) {
|
|
||||||
return new Promise((resolve, reject) => {
|
|
||||||
fetch_api(`api/v1.0/getFloAddressBalance?token=${token}&floAddress=${floID}`)
|
|
||||||
.then(result => resolve(result.balance || 0))
|
|
||||||
.catch(error => reject(error))
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
tokenAPI.getTx = function (txID) {
|
|
||||||
return new Promise((resolve, reject) => {
|
|
||||||
fetch_api(`api/v1.0/getTransactionDetails/${txID}`).then(res => {
|
|
||||||
if (res.result === "error")
|
|
||||||
reject(res.description);
|
|
||||||
else if (!res.parsedFloData)
|
|
||||||
reject("Data piece (parsedFloData) missing");
|
|
||||||
else if (!res.transactionDetails)
|
|
||||||
reject("Data piece (transactionDetails) missing");
|
|
||||||
else
|
|
||||||
resolve(res);
|
|
||||||
}).catch(error => reject(error))
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
tokenAPI.sendToken = function (privKey, amount, receiverID, message = "", token = DEFAULT.currency, options = {}) {
|
|
||||||
return new Promise((resolve, reject) => {
|
|
||||||
let senderID = floCrypto.getFloID(privKey);
|
|
||||||
if (typeof amount !== "number" || isNaN(amount) || amount <= 0)
|
|
||||||
return reject("Invalid amount");
|
|
||||||
getBalance(senderID, token).then(bal => {
|
|
||||||
if (amount > bal)
|
|
||||||
return reject(`Insufficient ${token}# balance`);
|
|
||||||
floBlockchainAPI.writeData(senderID, `send ${amount} ${token}# ${message}`, privKey, receiverID, options)
|
|
||||||
.then(txid => resolve(txid))
|
|
||||||
.catch(error => reject(error))
|
|
||||||
}).catch(error => reject(error))
|
|
||||||
});
|
|
||||||
}
|
|
||||||
|
|
||||||
function sendTokens_raw(privKey, receiverID, token, amount, utxo, vout, scriptPubKey) {
|
|
||||||
return new Promise((resolve, reject) => {
|
|
||||||
var trx = bitjs.transaction();
|
|
||||||
trx.addinput(utxo, vout, scriptPubKey)
|
|
||||||
trx.addoutput(receiverID, floBlockchainAPI.sendAmt);
|
|
||||||
trx.addflodata(`send ${amount} ${token}#`);
|
|
||||||
var signedTxHash = trx.sign(privKey, 1);
|
|
||||||
floBlockchainAPI.broadcastTx(signedTxHash)
|
|
||||||
.then(txid => resolve([receiverID, txid]))
|
|
||||||
.catch(error => reject([receiverID, error]))
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
//bulk transfer tokens
|
|
||||||
tokenAPI.bulkTransferTokens = function (sender, privKey, token, receivers) {
|
|
||||||
return new Promise((resolve, reject) => {
|
|
||||||
if (typeof receivers !== 'object')
|
|
||||||
return reject("receivers must be object in format {receiver1: amount1, receiver2:amount2...}")
|
|
||||||
|
|
||||||
let receiver_list = Object.keys(receivers), amount_list = Object.values(receivers);
|
|
||||||
let invalidReceivers = receiver_list.filter(id => !floCrypto.validateFloID(id));
|
|
||||||
let invalidAmount = amount_list.filter(val => typeof val !== 'number' || val <= 0);
|
|
||||||
if (invalidReceivers.length)
|
|
||||||
return reject(`Invalid receivers: ${invalidReceivers}`);
|
|
||||||
else if (invalidAmount.length)
|
|
||||||
return reject(`Invalid amounts: ${invalidAmount}`);
|
|
||||||
|
|
||||||
if (receiver_list.length == 0)
|
|
||||||
return reject("Receivers cannot be empty");
|
|
||||||
|
|
||||||
if (receiver_list.length == 1) {
|
|
||||||
let receiver = receiver_list[0], amount = amount_list[0];
|
|
||||||
floTokenAPI.sendToken(privKey, amount, receiver, "", token)
|
|
||||||
.then(txid => resolve({ success: { [receiver]: txid } }))
|
|
||||||
.catch(error => reject(error))
|
|
||||||
} else {
|
|
||||||
//check for token balance
|
|
||||||
floTokenAPI.getBalance(sender, token).then(token_balance => {
|
|
||||||
let total_token_amout = amount_list.reduce((a, e) => a + e, 0);
|
|
||||||
if (total_token_amout > token_balance)
|
|
||||||
return reject(`Insufficient ${token}# balance`);
|
|
||||||
|
|
||||||
//split utxos
|
|
||||||
floBlockchainAPI.splitUTXOs(sender, privKey, receiver_list.length).then(split_txid => {
|
|
||||||
//wait for the split utxo to get confirmation
|
|
||||||
floBlockchainAPI.waitForConfirmation(split_txid).then(split_tx => {
|
|
||||||
//send tokens using the split-utxo
|
|
||||||
var scriptPubKey = split_tx.vout[0].scriptPubKey.hex;
|
|
||||||
let promises = [];
|
|
||||||
for (let i in receiver_list)
|
|
||||||
promises.push(sendTokens_raw(privKey, receiver_list[i], token, amount_list[i], split_txid, i, scriptPubKey));
|
|
||||||
Promise.allSettled(promises).then(results => {
|
|
||||||
let success = Object.fromEntries(results.filter(r => r.status == 'fulfilled').map(r => r.value));
|
|
||||||
let failed = Object.fromEntries(results.filter(r => r.status == 'rejected').map(r => r.reason));
|
|
||||||
resolve({ success, failed });
|
|
||||||
})
|
|
||||||
}).catch(error => reject(error))
|
|
||||||
}).catch(error => reject(error))
|
|
||||||
}).catch(error => reject(error))
|
|
||||||
}
|
|
||||||
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
tokenAPI.getAllTxs = function (floID, token = DEFAULT.currency) {
|
|
||||||
return new Promise((resolve, reject) => {
|
|
||||||
fetch_api(`api/v1.0/getFloAddressTransactions?token=${token}&floAddress=${floID}`)
|
|
||||||
.then(result => resolve(result))
|
|
||||||
.catch(error => reject(error))
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
const util = tokenAPI.util = {};
|
|
||||||
|
|
||||||
util.parseTxData = function (txData) {
|
|
||||||
let parsedData = {};
|
|
||||||
for (let p in txData.parsedFloData)
|
|
||||||
parsedData[p] = txData.parsedFloData[p];
|
|
||||||
parsedData.sender = txData.transactionDetails.vin[0].addr;
|
|
||||||
for (let vout of txData.transactionDetails.vout)
|
|
||||||
if (vout.scriptPubKey.addresses[0] !== parsedData.sender)
|
|
||||||
parsedData.receiver = vout.scriptPubKey.addresses[0];
|
|
||||||
parsedData.time = txData.transactionDetails.time;
|
|
||||||
return parsedData;
|
|
||||||
}
|
|
||||||
|
|
||||||
})('object' === typeof module ? module.exports : window.floTokenAPI = {});
|
|
||||||
9975
docs/scripts/lib.js
9975
docs/scripts/lib.js
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue
Block a user