void-57
fd7b73c967
Implemented full wallet functionality for Ethereum Classic:
- Balance Checking: Real-time balance fetching for ETC and WETC.
- Transaction History: Robust fetching via BlockScout API with fallback CORS proxies and retry logic.
- Transaction Details: Detailed view for individual transactions, including status, hash, and value.
- Sending Functionality: Secure ETC transfers using Type 0 (Legacy) transactions.
- Key Management: Generate new addresses and retrieve existing ones from private keys (WIF).
- Navigation Enhancements:
- Clickable addresses in history for seamless navigation.
530 lines
20 KiB
JavaScript
530 lines
20 KiB
JavaScript
(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 = {}); |