]> git.immae.eu Git - perso/Immae/Projets/Cryptomonnaies/BIP39.git/blame - src/js/index.js
projects / perso / Immae / Projets / Cryptomonnaies / BIP39.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Add Binance Smart Chain (BSC) support
[perso/Immae/Projets/Cryptomonnaies/BIP39.git] / src / js / index.js
CommitLineData
ebd8d4e8
IC		 1(function() {
2
5ee7bb9e
IC		 3 // mnemonics is populated as required by getLanguage
4 var mnemonics = { "english": new Mnemonic("english") };
5 var mnemonic = mnemonics["english"];
3725abb5 6 var seed = null;
ebd8d4e8
IC		 7 var bip32RootKey = null;
8 var bip32ExtendedKey = null;
22f87669 9 var network = libs.bitcoin.networks.bitcoin;
ebd8d4e8
IC		 10 var addressRowTemplate = $("#address-row-template");
11
700901cd
IC		 12 var showIndex = true;
13 var showAddress = true;
1b12b2f5 14 var showPubKey = true;
700901cd 15 var showPrivKey = true;
8a93952c 16 var showQr = false;
1c2b8c6b 17 var litecoinUseLtub = true;
700901cd 18
516c16d7 19 var entropyTypeAutoDetect = true;
c6624d51 20 var entropyChangeTimeoutEvent = null;
ebd8d4e8 21 var phraseChangeTimeoutEvent = null;
9cf02dd4 22 var seedChangedTimeoutEvent = null;
efe41586 23 var rootKeyChangedTimeoutEvent = null;
ebd8d4e8 24
40892aba
IC		 25 var generationProcesses = [];
26
ebd8d4e8 27 var DOM = {};
0b6e351d 28 DOM.privacyScreenToggle = $(".privacy-screen-toggle");
d6cedc94 29 DOM.network = $(".network");
29bf60f5 30 DOM.bip32Client = $("#bip32-client");
d6cedc94 31 DOM.phraseNetwork = $("#network-phrase");
c6624d51
IC		 32 DOM.useEntropy = $(".use-entropy");
33 DOM.entropyContainer = $(".entropy-container");
34 DOM.entropy = $(".entropy");
0a84fe6a
IC		 35 DOM.entropyFiltered = DOM.entropyContainer.find(".filtered");
36 DOM.entropyType = DOM.entropyContainer.find(".type");
516c16d7 37 DOM.entropyTypeInputs = DOM.entropyContainer.find("input[name='entropy-type']");
20f459ce 38 DOM.entropyCrackTime = DOM.entropyContainer.find(".crack-time");
0a84fe6a
IC		 39 DOM.entropyEventCount = DOM.entropyContainer.find(".event-count");
40 DOM.entropyBits = DOM.entropyContainer.find(".bits");
41 DOM.entropyBitsPerEvent = DOM.entropyContainer.find(".bits-per-event");
42 DOM.entropyWordCount = DOM.entropyContainer.find(".word-count");
43 DOM.entropyBinary = DOM.entropyContainer.find(".binary");
74ab4cbe 44 DOM.entropyWordIndexes = DOM.entropyContainer.find(".word-indexes");
09d63290 45 DOM.entropyChecksum = DOM.entropyContainer.find(".checksum");
0a84fe6a 46 DOM.entropyMnemonicLength = DOM.entropyContainer.find(".mnemonic-length");
645945a0 47 DOM.entropyWeakEntropyOverrideWarning = DOM.entropyContainer.find(".weak-entropy-override-warning");
ee0981f1 48 DOM.entropyFilterWarning = DOM.entropyContainer.find(".filter-warning");
ebd8d4e8 49 DOM.phrase = $(".phrase");
f8fae68e 50 DOM.phraseSplit = $(".phraseSplit");
96ee8ab0 51 DOM.phraseSplitWarn = $(".phraseSplitWarn");
1abcc511 52 DOM.passphrase = $(".passphrase");
c6624d51 53 DOM.generateContainer = $(".generate-container");
ebd8d4e8 54 DOM.generate = $(".generate");
3e0ed16a 55 DOM.seed = $(".seed");
ebd8d4e8 56 DOM.rootKey = $(".root-key");
3abab9b0
IC		 57 DOM.litecoinLtubContainer = $(".litecoin-ltub-container");
58 DOM.litecoinUseLtub = $(".litecoin-use-ltub");
ebd8d4e8
IC		 59 DOM.extendedPrivKey = $(".extended-priv-key");
60 DOM.extendedPubKey = $(".extended-pub-key");
d6cedc94
IC		 61 DOM.bip32tab = $("#bip32-tab");
62 DOM.bip44tab = $("#bip44-tab");
6c08f364 63 DOM.bip49tab = $("#bip49-tab");
4e9b492c 64 DOM.bip84tab = $("#bip84-tab");
c49e8812 65 DOM.bip141tab = $("#bip141-tab");
d6cedc94
IC		 66 DOM.bip32panel = $("#bip32");
67 DOM.bip44panel = $("#bip44");
6c08f364 68 DOM.bip49panel = $("#bip49");
ebd8d4e8
IC		 69 DOM.bip32path = $("#bip32-path");
70 DOM.bip44path = $("#bip44-path");
71 DOM.bip44purpose = $("#bip44 .purpose");
72 DOM.bip44coin = $("#bip44 .coin");
73 DOM.bip44account = $("#bip44 .account");
c554e6ff
IC		 74 DOM.bip44accountXprv = $("#bip44 .account-xprv");
75 DOM.bip44accountXpub = $("#bip44 .account-xpub");
ebd8d4e8 76 DOM.bip44change = $("#bip44 .change");
6c08f364
IC		 77 DOM.bip49unavailable = $("#bip49 .unavailable");
78 DOM.bip49available = $("#bip49 .available");
79 DOM.bip49path = $("#bip49-path");
80 DOM.bip49purpose = $("#bip49 .purpose");
81 DOM.bip49coin = $("#bip49 .coin");
82 DOM.bip49account = $("#bip49 .account");
83 DOM.bip49accountXprv = $("#bip49 .account-xprv");
84 DOM.bip49accountXpub = $("#bip49 .account-xpub");
85 DOM.bip49change = $("#bip49 .change");
bddd5d9f
IC		 86 DOM.bip84unavailable = $("#bip84 .unavailable");
87 DOM.bip84available = $("#bip84 .available");
4e9b492c
IC		 88 DOM.bip84path = $("#bip84-path");
89 DOM.bip84purpose = $("#bip84 .purpose");
90 DOM.bip84coin = $("#bip84 .coin");
91 DOM.bip84account = $("#bip84 .account");
92 DOM.bip84accountXprv = $("#bip84 .account-xprv");
93 DOM.bip84accountXpub = $("#bip84 .account-xpub");
94 DOM.bip84change = $("#bip84 .change");
c49e8812
IC		 95 DOM.bip141unavailable = $("#bip141 .unavailable");
96 DOM.bip141available = $("#bip141 .available");
97 DOM.bip141path = $("#bip141-path");
98 DOM.bip141semantics = $(".bip141-semantics");
88df3739 99 DOM.generatedStrength = $(".generate-container .strength");
85c90672 100 DOM.generatedStrengthWarning = $(".generate-container .warning");
146e089e 101 DOM.hardenedAddresses = $(".hardened-addresses");
e0f91e20
IC		 102 DOM.bitcoinCashAddressTypeContainer = $(".bch-addr-type-container");
103 DOM.bitcoinCashAddressType = $("[name=bch-addr-type]")
0b39e9dc
IC		 104 DOM.useBip38 = $(".use-bip38");
105 DOM.bip38Password = $(".bip38-password");
ebd8d4e8 106 DOM.addresses = $(".addresses");
a78f4e28
IC		 107 DOM.csvTab = $("#csv-tab a");
108 DOM.csv = $(".csv");
ebd8d4e8
IC		 109 DOM.rowsToAdd = $(".rows-to-add");
110 DOM.more = $(".more");
9183f9f6 111 DOM.moreRowsStartIndex = $(".more-rows-start-index");
ebd8d4e8
IC		 112 DOM.feedback = $(".feedback");
113 DOM.tab = $(".derivation-type a");
114 DOM.indexToggle = $(".index-toggle");
115 DOM.addressToggle = $(".address-toggle");
1b12b2f5 116 DOM.publicKeyToggle = $(".public-key-toggle");
ebd8d4e8 117 DOM.privateKeyToggle = $(".private-key-toggle");
5ee7bb9e 118 DOM.languages = $(".languages a");
e00964cc 119 DOM.qrContainer = $(".qr-container");
97811c29 120 DOM.qrHider = DOM.qrContainer.find(".qr-hider");
e00964cc
IC		 121 DOM.qrImage = DOM.qrContainer.find(".qr-image");
122 DOM.qrHint = DOM.qrContainer.find(".qr-hint");
123 DOM.showQrEls = $("[data-show-qr]");
ebd8d4e8 124
ebd8d4e8
IC		 125 function init() {
126 // Events
0b6e351d 127 DOM.privacyScreenToggle.on("change", privacyScreenToggled);
85c90672 128 DOM.generatedStrength.on("change", generatedStrengthChanged);
d6cedc94 129 DOM.network.on("change", networkChanged);
29bf60f5 130 DOM.bip32Client.on("change", bip32ClientChanged);
c6624d51
IC		 131 DOM.useEntropy.on("change", setEntropyVisibility);
132 DOM.entropy.on("input", delayedEntropyChanged);
3599674d 133 DOM.entropyMnemonicLength.on("change", entropyChanged);
516c16d7 134 DOM.entropyTypeInputs.on("change", entropyTypeChanged);
a19a5498
IC		 135 DOM.phrase.on("input", delayedPhraseChanged);
136 DOM.passphrase.on("input", delayedPhraseChanged);
ebd8d4e8
IC		 137 DOM.generate.on("click", generateClicked);
138 DOM.more.on("click", showMore);
9cf02dd4 139 DOM.seed.on("input", delayedSeedChanged);
efe41586 140 DOM.rootKey.on("input", delayedRootKeyChanged);
3abab9b0 141 DOM.litecoinUseLtub.on("change", litecoinUseLtubChanged);
efe41586 142 DOM.bip32path.on("input", calcForDerivationPath);
efe41586
IC		 143 DOM.bip44account.on("input", calcForDerivationPath);
144 DOM.bip44change.on("input", calcForDerivationPath);
6c08f364
IC		 145 DOM.bip49account.on("input", calcForDerivationPath);
146 DOM.bip49change.on("input", calcForDerivationPath);
4e9b492c
IC		 147 DOM.bip84account.on("input", calcForDerivationPath);
148 DOM.bip84change.on("input", calcForDerivationPath);
c49e8812
IC		 149 DOM.bip141path.on("input", calcForDerivationPath);
150 DOM.bip141semantics.on("change", tabChanged);
93c3ef47 151 DOM.tab.on("shown.bs.tab", tabChanged);
146e089e 152 DOM.hardenedAddresses.on("change", calcForDerivationPath);
0b39e9dc
IC		 153 DOM.useBip38.on("change", calcForDerivationPath);
154 DOM.bip38Password.on("change", calcForDerivationPath);
ebd8d4e8
IC		 155 DOM.indexToggle.on("click", toggleIndexes);
156 DOM.addressToggle.on("click", toggleAddresses);
1b12b2f5 157 DOM.publicKeyToggle.on("click", togglePublicKeys);
ebd8d4e8 158 DOM.privateKeyToggle.on("click", togglePrivateKeys);
a78f4e28 159 DOM.csvTab.on("click", updateCsv);
5ee7bb9e 160 DOM.languages.on("click", languageChanged);
e0f91e20 161 DOM.bitcoinCashAddressType.on("change", bitcoinCashAddressTypeChange);
e00964cc 162 setQrEvents(DOM.showQrEls);
ebd8d4e8
IC		 163 disableForms();
164 hidePending();
165 hideValidationError();
7f15cb6e 166 populateNetworkSelect();
b4fd763c 167 populateClientSelect();
ebd8d4e8
IC		 168 }
169
170 // Event handlers
171
85c90672
IC		 172 function generatedStrengthChanged() {
173 var strength = parseInt(DOM.generatedStrength.val());
174 if (strength < 12) {
175 DOM.generatedStrengthWarning.removeClass("hidden");
176 }
177 else {
178 DOM.generatedStrengthWarning.addClass("hidden");
179 }
180 }
181
d6cedc94 182 function networkChanged(e) {
6c08f364
IC		 183 clearDerivedKeys();
184 clearAddressesList();
3abab9b0 185 DOM.litecoinLtubContainer.addClass("hidden");
e0f91e20 186 DOM.bitcoinCashAddressTypeContainer.addClass("hidden");
54563907 187 var networkIndex = e.target.value;
6c08f364
IC		 188 var network = networks[networkIndex];
189 network.onSelect();
c147cb5e 190 adjustNetworkForSegwit();
54563907
IC		 191 if (seed != null) {
192 phraseChanged();
193 }
194 else {
195 rootKeyChanged();
196 }
d6cedc94 197 }
29bf60f5
IC		 198
199 function bip32ClientChanged(e) {
200 var clientIndex = DOM.bip32Client.val();
201 if (clientIndex == "custom") {
202 DOM.bip32path.prop("readonly", false);
b4fd763c
AG		 203 }
204 else {
29bf60f5
IC		 205 DOM.bip32path.prop("readonly", true);
206 clients[clientIndex].onSelect();
207 if (seed != null) {
208 phraseChanged();
209 }
210 else {
211 rootKeyChanged();
212 }
b4fd763c
AG		 213 }
214 }
d6cedc94 215
c6624d51
IC		 216 function setEntropyVisibility() {
217 if (isUsingOwnEntropy()) {
218 DOM.entropyContainer.removeClass("hidden");
219 DOM.generateContainer.addClass("hidden");
220 DOM.phrase.prop("readonly", true);
221 DOM.entropy.focus();
222 entropyChanged();
223 }
224 else {
225 DOM.entropyContainer.addClass("hidden");
226 DOM.generateContainer.removeClass("hidden");
227 DOM.phrase.prop("readonly", false);
057722b0 228 hidePending();
c6624d51
IC		 229 }
230 }
231
ebd8d4e8
IC		 232 function delayedPhraseChanged() {
233 hideValidationError();
ed6d9d39
IC		 234 seed = null;
235 bip32RootKey = null;
236 bip32ExtendedKey = null;
237 clearAddressesList();
ebd8d4e8
IC		 238 showPending();
239 if (phraseChangeTimeoutEvent != null) {
240 clearTimeout(phraseChangeTimeoutEvent);
241 }
611f7623
KC		 242 phraseChangeTimeoutEvent = setTimeout(function() {
243 phraseChanged();
244c7602 244 var entropy = mnemonic.toRawEntropyHex(DOM.phrase.val());
611f7623
KC		 245 if (entropy !== null) {
246 DOM.entropyMnemonicLength.val("raw");
247 DOM.entropy.val(entropy);
244c7602
IC		 248 DOM.entropyTypeInputs.filter("[value='hexadecimal']").prop("checked", true);
249 entropyTypeAutoDetect = false;
611f7623
KC		 250 }
251 }, 400);
ebd8d4e8
IC		 252 }
253
254 function phraseChanged() {
255 showPending();
5ee7bb9e 256 setMnemonicLanguage();
ebd8d4e8
IC		 257 // Get the mnemonic phrase
258 var phrase = DOM.phrase.val();
259 var errorText = findPhraseErrors(phrase);
260 if (errorText) {
261 showValidationError(errorText);
262 return;
263 }
efe41586
IC		 264 // Calculate and display
265 var passphrase = DOM.passphrase.val();
266 calcBip32RootKeyFromSeed(phrase, passphrase);
267 calcForDerivationPath();
74ab4cbe
IC		 268 // Show the word indexes
269 showWordIndexes();
a04946e2 270 writeSplitPhrase(phrase);
efe41586
IC		 271 }
272
93c3ef47
IC		 273 function tabChanged() {
274 showPending();
0fd67b59 275 adjustNetworkForSegwit();
93c3ef47
IC		 276 var phrase = DOM.phrase.val();
277 if (phrase != "") {
278 // Calculate and display for mnemonic
279 var errorText = findPhraseErrors(phrase);
280 if (errorText) {
281 showValidationError(errorText);
282 return;
283 }
284 // Calculate and display
285 var passphrase = DOM.passphrase.val();
286 calcBip32RootKeyFromSeed(phrase, passphrase);
287 }
288 else {
289 // Calculate and display for root key
290 var rootKeyBase58 = DOM.rootKey.val();
291 var errorText = validateRootKey(rootKeyBase58);
292 if (errorText) {
293 showValidationError(errorText);
294 return;
295 }
296 // Calculate and display
297 calcBip32RootKeyFromBase58(rootKeyBase58);
298 }
299 calcForDerivationPath();
300 }
301
c6624d51
IC		 302 function delayedEntropyChanged() {
303 hideValidationError();
304 showPending();
305 if (entropyChangeTimeoutEvent != null) {
306 clearTimeout(entropyChangeTimeoutEvent);
307 }
308 entropyChangeTimeoutEvent = setTimeout(entropyChanged, 400);
309 }
310
311 function entropyChanged() {
057722b0
IC		 312 // If blank entropy, clear mnemonic, addresses, errors
313 if (DOM.entropy.val().trim().length == 0) {
314 clearDisplay();
0a84fe6a 315 clearEntropyFeedback();
057722b0 316 DOM.phrase.val("");
96ee8ab0 317 DOM.phraseSplit.val("");
057722b0
IC		 318 showValidationError("Blank entropy");
319 return;
320 }
321 // Get the current phrase to detect changes
322 var phrase = DOM.phrase.val();
323 // Set the phrase from the entropy
c6624d51 324 setMnemonicFromEntropy();
057722b0
IC		 325 // Recalc addresses if the phrase has changed
326 var newPhrase = DOM.phrase.val();
327 if (newPhrase != phrase) {
328 if (newPhrase.length == 0) {
329 clearDisplay();
330 }
331 else {
332 phraseChanged();
333 }
334 }
335 else {
336 hidePending();
337 }
c6624d51
IC		 338 }
339
516c16d7
IC		 340 function entropyTypeChanged() {
341 entropyTypeAutoDetect = false;
342 entropyChanged();
343 }
344
9cf02dd4
IC		 345 function delayedSeedChanged() {
346 // Warn if there is an existing mnemonic or passphrase.
347 if (DOM.phrase.val().length > 0 || DOM.passphrase.val().length > 0) {
348 if (!confirm("This will clear existing mnemonic and passphrase")) {
349 DOM.seed.val(seed);
350 return
351 }
352 }
353 hideValidationError();
354 showPending();
355 // Clear existing mnemonic and passphrase
356 DOM.phrase.val("");
357 DOM.phraseSplit.val("");
358 DOM.passphrase.val("");
359 DOM.rootKey.val("");
360 clearAddressesList();
361 clearDerivedKeys();
362 seed = null;
363 if (seedChangedTimeoutEvent != null) {
364 clearTimeout(seedChangedTimeoutEvent);
365 }
366 seedChangedTimeoutEvent = setTimeout(seedChanged, 400);
367 }
368
efe41586
IC		 369 function delayedRootKeyChanged() {
370 // Warn if there is an existing mnemonic or passphrase.
371 if (DOM.phrase.val().length > 0 || DOM.passphrase.val().length > 0) {
372 if (!confirm("This will clear existing mnemonic and passphrase")) {
373 DOM.rootKey.val(bip32RootKey);
374 return
375 }
376 }
377 hideValidationError();
378 showPending();
379 // Clear existing mnemonic and passphrase
380 DOM.phrase.val("");
96ee8ab0 381 DOM.phraseSplit.val("");
efe41586
IC		 382 DOM.passphrase.val("");
383 seed = null;
384 if (rootKeyChangedTimeoutEvent != null) {
385 clearTimeout(rootKeyChangedTimeoutEvent);
386 }
387 rootKeyChangedTimeoutEvent = setTimeout(rootKeyChanged, 400);
388 }
389
9cf02dd4
IC		 390 function seedChanged() {
391 showPending();
392 hideValidationError();
393 seed = DOM.seed.val();
22f87669 394 bip32RootKey = libs.bitcoin.HDNode.fromSeedHex(seed, network);
9cf02dd4
IC		 395 var rootKeyBase58 = bip32RootKey.toBase58();
396 DOM.rootKey.val(rootKeyBase58);
397 var errorText = validateRootKey(rootKeyBase58);
398 if (errorText) {
399 showValidationError(errorText);
400 return;
401 }
402 // Calculate and display
403 calcForDerivationPath();
404 }
405
efe41586
IC		 406 function rootKeyChanged() {
407 showPending();
408 hideValidationError();
efe41586
IC		 409 var rootKeyBase58 = DOM.rootKey.val();
410 var errorText = validateRootKey(rootKeyBase58);
411 if (errorText) {
412 showValidationError(errorText);
413 return;
414 }
415 // Calculate and display
416 calcBip32RootKeyFromBase58(rootKeyBase58);
417 calcForDerivationPath();
efe41586
IC		 418 }
419
3abab9b0
IC		 420 function litecoinUseLtubChanged() {
421 litecoinUseLtub = DOM.litecoinUseLtub.prop("checked");
422 if (litecoinUseLtub) {
22f87669 423 network = libs.bitcoin.networks.litecoin;
3abab9b0
IC		 424 }
425 else {
22f87669 426 network = libs.bitcoin.networks.litecoinXprv;
3abab9b0
IC		 427 }
428 phraseChanged();
429 }
430
efe41586 431 function calcForDerivationPath() {
6c08f364 432 clearDerivedKeys();
ba3cb9ec 433 clearAddressesList();
0eda54f5 434 showPending();
0fd67b59
IC		 435 // Don't show segwit if it's selected but network doesn't support it
436 if (segwitSelected() && !networkHasSegwit()) {
c147cb5e 437 showSegwitUnavailable();
7733ac32 438 hidePending();
6c08f364
IC		 439 return;
440 }
c147cb5e 441 showSegwitAvailable();
ebd8d4e8 442 // Get the derivation path
38523d36
IC		 443 var derivationPath = getDerivationPath();
444 var errorText = findDerivationPathErrors(derivationPath);
ebd8d4e8
IC		 445 if (errorText) {
446 showValidationError(errorText);
447 return;
448 }
5eaa6877 449 bip32ExtendedKey = calcBip32ExtendedKey(derivationPath);
c554e6ff
IC		 450 if (bip44TabSelected()) {
451 displayBip44Info();
452 }
c49e8812 453 else if (bip49TabSelected()) {
6c08f364
IC		 454 displayBip49Info();
455 }
4e9b492c
IC		 456 else if (bip84TabSelected()) {
457 displayBip84Info();
458 }
ebd8d4e8 459 displayBip32Info();
ebd8d4e8
IC		 460 }
461
462 function generateClicked() {
c6624d51
IC		 463 if (isUsingOwnEntropy()) {
464 return;
465 }
ebd8d4e8
IC		 466 clearDisplay();
467 showPending();
468 setTimeout(function() {
5ee7bb9e 469 setMnemonicLanguage();
ebd8d4e8
IC		 470 var phrase = generateRandomPhrase();
471 if (!phrase) {
472 return;
473 }
474 phraseChanged();
475 }, 50);
476 }
477
5ee7bb9e
IC		 478 function languageChanged() {
479 setTimeout(function() {
480 setMnemonicLanguage();
481 if (DOM.phrase.val().length > 0) {
482 var newPhrase = convertPhraseToNewLanguage();
483 DOM.phrase.val(newPhrase);
484 phraseChanged();
485 }
486 else {
487 DOM.generate.trigger("click");
488 }
489 }, 50);
490 }
491
e0f91e20 492 function bitcoinCashAddressTypeChange() {
fe8f2d14
IC		 493 phraseChanged();
494 }
495
ebd8d4e8 496 function toggleIndexes() {
700901cd 497 showIndex = !showIndex;
ebd8d4e8
IC		 498 $("td.index span").toggleClass("invisible");
499 }
500
501 function toggleAddresses() {
700901cd 502 showAddress = !showAddress;
ebd8d4e8
IC		 503 $("td.address span").toggleClass("invisible");
504 }
505
1b12b2f5
IC		 506 function togglePublicKeys() {
507 showPubKey = !showPubKey;
508 $("td.pubkey span").toggleClass("invisible");
509 }
510
ebd8d4e8 511 function togglePrivateKeys() {
700901cd 512 showPrivKey = !showPrivKey;
ebd8d4e8
IC		 513 $("td.privkey span").toggleClass("invisible");
514 }
515
0b6e351d
IC		 516 function privacyScreenToggled() {
517 // private-data contains elements added to DOM at runtime
518 // so catch all by adding visual privacy class to the root of the DOM
519 if (DOM.privacyScreenToggle.prop("checked")) {
520 $("body").addClass("visual-privacy");
521 }
522 else {
523 $("body").removeClass("visual-privacy");
524 }
525 }
526
ebd8d4e8
IC		 527 // Private methods
528
529 function generateRandomPhrase() {
530 if (!hasStrongRandom()) {
531 var errorText = "This browser does not support strong randomness";
532 showValidationError(errorText);
533 return;
534 }
74ab4cbe 535 // get the amount of entropy to use
88df3739 536 var numWords = parseInt(DOM.generatedStrength.val());
ebd8d4e8 537 var strength = numWords / 3 * 32;
74ab4cbe
IC		 538 var buffer = new Uint8Array(strength / 8);
539 // create secure entropy
540 var data = crypto.getRandomValues(buffer);
541 // show the words
542 var words = mnemonic.toMnemonic(data);
ebd8d4e8 543 DOM.phrase.val(words);
74ab4cbe
IC		 544 // show the entropy
545 var entropyHex = uint8ArrayToHex(data);
546 DOM.entropy.val(entropyHex);
547 // ensure entropy fields are consistent with what is being displayed
548 DOM.entropyMnemonicLength.val("raw");
ebd8d4e8
IC		 549 return words;
550 }
551
efe41586 552 function calcBip32RootKeyFromSeed(phrase, passphrase) {
3e0ed16a 553 seed = mnemonic.toSeed(phrase, passphrase);
22f87669 554 bip32RootKey = libs.bitcoin.HDNode.fromSeedHex(seed, network);
76120cb0 555 if(isGRS())
22f87669 556 bip32RootKey = libs.groestlcoinjs.HDNode.fromSeedHex(seed, network);
76120cb0 557
efe41586
IC		 558 }
559
560 function calcBip32RootKeyFromBase58(rootKeyBase58) {
76120cb0
H		 561 if(isGRS()) {
562 calcBip32RootKeyFromBase58GRS(rootKeyBase58);
563 return;
564 }
6f7fa353
IC		 565 // try parsing with various segwit network params since this extended
566 // key may be from any one of them.
567 if (networkHasSegwit()) {
568 var n = network;
569 if ("baseNetwork" in n) {
22f87669 570 n = libs.bitcoin.networks[n.baseNetwork];
6f7fa353
IC		 571 }
572 // try parsing using base network params
573 try {
22f87669 574 bip32RootKey = libs.bitcoin.HDNode.fromBase58(rootKeyBase58, n);
6f7fa353
IC		 575 return;
576 }
577 catch (e) {}
578 // try parsing using p2wpkh params
579 if ("p2wpkh" in n) {
580 try {
22f87669 581 bip32RootKey = libs.bitcoin.HDNode.fromBase58(rootKeyBase58, n.p2wpkh);
6f7fa353
IC		 582 return;
583 }
584 catch (e) {}
585 }
586 // try parsing using p2wpkh-in-p2sh network params
587 if ("p2wpkhInP2sh" in n) {
588 try {
22f87669 589 bip32RootKey = libs.bitcoin.HDNode.fromBase58(rootKeyBase58, n.p2wpkhInP2sh);
6f7fa353
IC		 590 return;
591 }
592 catch (e) {}
593 }
5c203fab
IC		 594 // try parsing using p2wsh network params
595 if ("p2wsh" in n) {
596 try {
22f87669 597 bip32RootKey = libs.bitcoin.HDNode.fromBase58(rootKeyBase58, n.p2wsh);
5c203fab
IC		 598 return;
599 }
600 catch (e) {}
601 }
602 // try parsing using p2wsh-in-p2sh network params
603 if ("p2wshInP2sh" in n) {
604 try {
22f87669 605 bip32RootKey = libs.bitcoin.HDNode.fromBase58(rootKeyBase58, n.p2wshInP2sh);
5c203fab
IC		 606 return;
607 }
608 catch (e) {}
609 }
6f7fa353
IC		 610 }
611 // try the network params as currently specified
22f87669 612 bip32RootKey = libs.bitcoin.HDNode.fromBase58(rootKeyBase58, network);
efe41586
IC		 613 }
614
76120cb0
H		 615 function calcBip32RootKeyFromBase58GRS(rootKeyBase58) {
616 // try parsing with various segwit network params since this extended
617 // key may be from any one of them.
618 if (networkHasSegwit()) {
619 var n = network;
620 if ("baseNetwork" in n) {
22f87669 621 n = libs.bitcoin.networks[n.baseNetwork];
76120cb0
H		 622 }
623 // try parsing using base network params
624 try {
22f87669 625 bip32RootKey = libs.groestlcoinjs.HDNode.fromBase58(rootKeyBase58, n);
76120cb0
H		 626 return;
627 }
628 catch (e) {}
629 // try parsing using p2wpkh params
630 if ("p2wpkh" in n) {
631 try {
22f87669 632 bip32RootKey = libs.groestlcoinjs.HDNode.fromBase58(rootKeyBase58, n.p2wpkh);
76120cb0
H		 633 return;
634 }
635 catch (e) {}
636 }
637 // try parsing using p2wpkh-in-p2sh network params
638 if ("p2wpkhInP2sh" in n) {
639 try {
22f87669 640 bip32RootKey = libs.groestlcoinjs.HDNode.fromBase58(rootKeyBase58, n.p2wpkhInP2sh);
76120cb0
H		 641 return;
642 }
643 catch (e) {}
644 }
645 }
646 // try the network params as currently specified
22f87669 647 bip32RootKey = libs.groestlcoinjs.HDNode.fromBase58(rootKeyBase58, network);
76120cb0
H		 648 }
649
efe41586 650 function calcBip32ExtendedKey(path) {
0a1f0259
IC		 651 // Check there's a root key to derive from
652 if (!bip32RootKey) {
653 return bip32RootKey;
654 }
5eaa6877 655 var extendedKey = bip32RootKey;
ebd8d4e8
IC		 656 // Derive the key from the path
657 var pathBits = path.split("/");
658 for (var i=0; i<pathBits.length; i++) {
659 var bit = pathBits[i];
660 var index = parseInt(bit);
661 if (isNaN(index)) {
662 continue;
663 }
664 var hardened = bit[bit.length-1] == "'";
a0091a40 665 var isPriv = !(extendedKey.isNeutered());
ba3cb9ec
IC		 666 var invalidDerivationPath = hardened && !isPriv;
667 if (invalidDerivationPath) {
668 extendedKey = null;
669 }
670 else if (hardened) {
5eaa6877 671 extendedKey = extendedKey.deriveHardened(index);
ebd8d4e8
IC		 672 }
673 else {
5eaa6877 674 extendedKey = extendedKey.derive(index);
ebd8d4e8
IC		 675 }
676 }
36523e0d 677 return extendedKey;
ebd8d4e8
IC		 678 }
679
680 function showValidationError(errorText) {
681 DOM.feedback
682 .text(errorText)
683 .show();
684 }
685
686 function hideValidationError() {
687 DOM.feedback
688 .text("")
689 .hide();
690 }
691
692 function findPhraseErrors(phrase) {
ebd8d4e8 693 // Preprocess the words
783981de 694 phrase = mnemonic.normalizeString(phrase);
5ee7bb9e 695 var words = phraseToWordArray(phrase);
057722b0
IC		 696 // Detect blank phrase
697 if (words.length == 0) {
698 return "Blank mnemonic";
699 }
563e401a 700 // Check each word
5ee7bb9e
IC		 701 for (var i=0; i<words.length; i++) {
702 var word = words[i];
703 var language = getLanguage();
704 if (WORDLISTS[language].indexOf(word) == -1) {
563e401a
IC		 705 console.log("Finding closest match to " + word);
706 var nearestWord = findNearestWord(word);
707 return word + " not in wordlist, did you mean " + nearestWord + "?";
708 }
709 }
ebd8d4e8 710 // Check the words are valid
5ee7bb9e 711 var properPhrase = wordArrayToPhrase(words);
ebd8d4e8
IC		 712 var isValid = mnemonic.check(properPhrase);
713 if (!isValid) {
714 return "Invalid mnemonic";
715 }
716 return false;
717 }
718
efe41586 719 function validateRootKey(rootKeyBase58) {
75138bee 720 if(isGRS())
76120cb0 721 return validateRootKeyGRS(rootKeyBase58);
75138bee 722
6f7fa353
IC		 723 // try various segwit network params since this extended key may be from
724 // any one of them.
725 if (networkHasSegwit()) {
726 var n = network;
727 if ("baseNetwork" in n) {
22f87669 728 n = libs.bitcoin.networks[n.baseNetwork];
6f7fa353
IC		 729 }
730 // try parsing using base network params
731 try {
22f87669 732 libs.bitcoin.HDNode.fromBase58(rootKeyBase58, n);
6f7fa353
IC		 733 return "";
734 }
735 catch (e) {}
736 // try parsing using p2wpkh params
737 if ("p2wpkh" in n) {
738 try {
22f87669 739 libs.bitcoin.HDNode.fromBase58(rootKeyBase58, n.p2wpkh);
6f7fa353
IC		 740 return "";
741 }
742 catch (e) {}
743 }
744 // try parsing using p2wpkh-in-p2sh network params
745 if ("p2wpkhInP2sh" in n) {
746 try {
22f87669 747 libs.bitcoin.HDNode.fromBase58(rootKeyBase58, n.p2wpkhInP2sh);
6f7fa353
IC		 748 return "";
749 }
750 catch (e) {}
751 }
5c203fab
IC		 752 // try parsing using p2wsh network params
753 if ("p2wsh" in n) {
754 try {
22f87669 755 libs.bitcoin.HDNode.fromBase58(rootKeyBase58, n.p2wsh);
5c203fab
IC		 756 return "";
757 }
758 catch (e) {}
759 }
760 // try parsing using p2wsh-in-p2sh network params
761 if ("p2wshInP2sh" in n) {
762 try {
22f87669 763 libs.bitcoin.HDNode.fromBase58(rootKeyBase58, n.p2wshInP2sh);
5c203fab
IC		 764 return "";
765 }
766 catch (e) {}
767 }
6f7fa353
IC		 768 }
769 // try the network params as currently specified
efe41586 770 try {
22f87669 771 libs.bitcoin.HDNode.fromBase58(rootKeyBase58, network);
efe41586
IC		 772 }
773 catch (e) {
774 return "Invalid root key";
775 }
776 return "";
777 }
778
76120cb0
H		 779 function validateRootKeyGRS(rootKeyBase58) {
780 // try various segwit network params since this extended key may be from
781 // any one of them.
782 if (networkHasSegwit()) {
783 var n = network;
784 if ("baseNetwork" in n) {
22f87669 785 n = libs.bitcoin.networks[n.baseNetwork];
76120cb0
H		 786 }
787 // try parsing using base network params
788 try {
22f87669 789 libs.groestlcoinjs.HDNode.fromBase58(rootKeyBase58, n);
76120cb0
H		 790 return "";
791 }
792 catch (e) {}
793 // try parsing using p2wpkh params
794 if ("p2wpkh" in n) {
795 try {
22f87669 796 libs.groestlcoinjs.HDNode.fromBase58(rootKeyBase58, n.p2wpkh);
76120cb0
H		 797 return "";
798 }
799 catch (e) {}
800 }
801 // try parsing using p2wpkh-in-p2sh network params
802 if ("p2wpkhInP2sh" in n) {
803 try {
22f87669 804 libs.groestlcoinjs.HDNode.fromBase58(rootKeyBase58, n.p2wpkhInP2sh);
76120cb0
H		 805 return "";
806 }
807 catch (e) {}
808 }
809 }
810 // try the network params as currently specified
811 try {
22f87669 812 libs.groestlcoinjs.HDNode.fromBase58(rootKeyBase58, network);
76120cb0
H		 813 }
814 catch (e) {
815 return "Invalid root key";
816 }
817 return "";
818 }
819
38523d36 820 function getDerivationPath() {
32fab2c3 821 if (bip44TabSelected()) {
38523d36
IC		 822 var purpose = parseIntNoNaN(DOM.bip44purpose.val(), 44);
823 var coin = parseIntNoNaN(DOM.bip44coin.val(), 0);
824 var account = parseIntNoNaN(DOM.bip44account.val(), 0);
55367b98
IC		 825 var change = parseIntNoNaN(DOM.bip44change.val(), 0);
826 var path = "m/";
827 path += purpose + "'/";
828 path += coin + "'/";
829 path += account + "'/";
830 path += change;
38523d36
IC		 831 DOM.bip44path.val(path);
832 var derivationPath = DOM.bip44path.val();
833 console.log("Using derivation path from BIP44 tab: " + derivationPath);
834 return derivationPath;
835 }
c49e8812 836 else if (bip49TabSelected()) {
6c08f364
IC		 837 var purpose = parseIntNoNaN(DOM.bip49purpose.val(), 49);
838 var coin = parseIntNoNaN(DOM.bip49coin.val(), 0);
839 var account = parseIntNoNaN(DOM.bip49account.val(), 0);
840 var change = parseIntNoNaN(DOM.bip49change.val(), 0);
841 var path = "m/";
842 path += purpose + "'/";
843 path += coin + "'/";
844 path += account + "'/";
845 path += change;
846 DOM.bip49path.val(path);
847 var derivationPath = DOM.bip49path.val();
848 console.log("Using derivation path from BIP49 tab: " + derivationPath);
849 return derivationPath;
850 }
4e9b492c
IC		 851 else if (bip84TabSelected()) {
852 var purpose = parseIntNoNaN(DOM.bip84purpose.val(), 84);
853 var coin = parseIntNoNaN(DOM.bip84coin.val(), 0);
854 var account = parseIntNoNaN(DOM.bip84account.val(), 0);
855 var change = parseIntNoNaN(DOM.bip84change.val(), 0);
856 var path = "m/";
857 path += purpose + "'/";
858 path += coin + "'/";
859 path += account + "'/";
860 path += change;
861 DOM.bip84path.val(path);
862 var derivationPath = DOM.bip84path.val();
863 console.log("Using derivation path from BIP84 tab: " + derivationPath);
864 return derivationPath;
865 }
32fab2c3 866 else if (bip32TabSelected()) {
38523d36
IC		 867 var derivationPath = DOM.bip32path.val();
868 console.log("Using derivation path from BIP32 tab: " + derivationPath);
869 return derivationPath;
870 }
c49e8812
IC		 871 else if (bip141TabSelected()) {
872 var derivationPath = DOM.bip141path.val();
873 console.log("Using derivation path from BIP141 tab: " + derivationPath);
874 return derivationPath;
875 }
38523d36
IC		 876 else {
877 console.log("Unknown derivation path");
878 }
879 }
880
ebd8d4e8 881 function findDerivationPathErrors(path) {
30c9e79d
IC		 882 // TODO is not perfect but is better than nothing
883 // Inspired by
884 // https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#test-vectors
885 // and
886 // https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#extended-keys
887 var maxDepth = 255; // TODO verify this!!
888 var maxIndexValue = Math.pow(2, 31); // TODO verify this!!
889 if (path[0] != "m") {
890 return "First character must be 'm'";
891 }
892 if (path.length > 1) {
893 if (path[1] != "/") {
894 return "Separator must be '/'";
895 }
896 var indexes = path.split("/");
897 if (indexes.length > maxDepth) {
898 return "Derivation depth is " + indexes.length + ", must be less than " + maxDepth;
899 }
900 for (var depth = 1; depth<indexes.length; depth++) {
901 var index = indexes[depth];
902 var invalidChars = index.replace(/^[0-9]+'?$/g, "")
903 if (invalidChars.length > 0) {
904 return "Invalid characters " + invalidChars + " found at depth " + depth;
905 }
906 var indexValue = parseInt(index.replace("'", ""));
907 if (isNaN(depth)) {
908 return "Invalid number at depth " + depth;
909 }
910 if (indexValue > maxIndexValue) {
911 return "Value of " + indexValue + " at depth " + depth + " must be less than " + maxIndexValue;
912 }
913 }
914 }
0a1f0259
IC		 915 // Check root key exists or else derivation path is useless!
916 if (!bip32RootKey) {
917 return "No root key";
918 }
ba3cb9ec 919 // Check no hardened derivation path when using xpub keys
b18eb97a
IC		 920 var hardenedPath = path.indexOf("'") > -1;
921 var hardenedAddresses = bip32TabSelected() && DOM.hardenedAddresses.prop("checked");
922 var hardened = hardenedPath || hardenedAddresses;
a0091a40 923 var isXpubkey = bip32RootKey.isNeutered();
ba3cb9ec
IC		 924 if (hardened && isXpubkey) {
925 return "Hardened derivation path is invalid with xpub key";
926 }
ebd8d4e8
IC		 927 return false;
928 }
929
76120cb0
H		 930 function isGRS() {
931 return networks[DOM.network.val()].name == "GRS - Groestlcoin" || networks[DOM.network.val()].name == "GRS - Groestlcoin Testnet";
932 }
933
36523e0d
NJ		 934 function isELA() {
935 return networks[DOM.network.val()].name == "ELA - Elastos"
936 }
937
c554e6ff
IC		 938 function displayBip44Info() {
939 // Get the derivation path for the account
940 var purpose = parseIntNoNaN(DOM.bip44purpose.val(), 44);
941 var coin = parseIntNoNaN(DOM.bip44coin.val(), 0);
942 var account = parseIntNoNaN(DOM.bip44account.val(), 0);
943 var path = "m/";
944 path += purpose + "'/";
945 path += coin + "'/";
946 path += account + "'/";
947 // Calculate the account extended keys
948 var accountExtendedKey = calcBip32ExtendedKey(path);
949 var accountXprv = accountExtendedKey.toBase58();
a0091a40 950 var accountXpub = accountExtendedKey.neutered().toBase58();
36523e0d 951
c554e6ff
IC		 952 // Display the extended keys
953 DOM.bip44accountXprv.val(accountXprv);
954 DOM.bip44accountXpub.val(accountXpub);
36523e0d
NJ		 955
956 if (isELA()) {
957 displayBip44InfoForELA();
958 }
c554e6ff
IC		 959 }
960
6c08f364
IC		 961 function displayBip49Info() {
962 // Get the derivation path for the account
963 var purpose = parseIntNoNaN(DOM.bip49purpose.val(), 49);
964 var coin = parseIntNoNaN(DOM.bip49coin.val(), 0);
965 var account = parseIntNoNaN(DOM.bip49account.val(), 0);
966 var path = "m/";
967 path += purpose + "'/";
968 path += coin + "'/";
969 path += account + "'/";
970 // Calculate the account extended keys
971 var accountExtendedKey = calcBip32ExtendedKey(path);
972 var accountXprv = accountExtendedKey.toBase58();
973 var accountXpub = accountExtendedKey.neutered().toBase58();
974 // Display the extended keys
975 DOM.bip49accountXprv.val(accountXprv);
976 DOM.bip49accountXpub.val(accountXpub);
977 }
978
4e9b492c
IC		 979 function displayBip84Info() {
980 // Get the derivation path for the account
981 var purpose = parseIntNoNaN(DOM.bip84purpose.val(), 84);
982 var coin = parseIntNoNaN(DOM.bip84coin.val(), 0);
983 var account = parseIntNoNaN(DOM.bip84account.val(), 0);
984 var path = "m/";
985 path += purpose + "'/";
986 path += coin + "'/";
987 path += account + "'/";
988 // Calculate the account extended keys
989 var accountExtendedKey = calcBip32ExtendedKey(path);
990 var accountXprv = accountExtendedKey.toBase58();
991 var accountXpub = accountExtendedKey.neutered().toBase58();
992 // Display the extended keys
993 DOM.bip84accountXprv.val(accountXprv);
994 DOM.bip84accountXpub.val(accountXpub);
995 }
996
ebd8d4e8
IC		 997 function displayBip32Info() {
998 // Display the key
3e0ed16a 999 DOM.seed.val(seed);
ebd8d4e8
IC		 1000 var rootKey = bip32RootKey.toBase58();
1001 DOM.rootKey.val(rootKey);
ba3cb9ec 1002 var xprvkeyB58 = "NA";
a0091a40 1003 if (!bip32ExtendedKey.isNeutered()) {
ba3cb9ec
IC		 1004 xprvkeyB58 = bip32ExtendedKey.toBase58();
1005 }
1006 var extendedPrivKey = xprvkeyB58;
ebd8d4e8 1007 DOM.extendedPrivKey.val(extendedPrivKey);
a0091a40 1008 var extendedPubKey = bip32ExtendedKey.neutered().toBase58();
ebd8d4e8
IC		 1009 DOM.extendedPubKey.val(extendedPubKey);
1010 // Display the addresses and privkeys
1011 clearAddressesList();
ba678b11
IC		 1012 var initialAddressCount = parseInt(DOM.rowsToAdd.val());
1013 displayAddresses(0, initialAddressCount);
36523e0d
NJ		 1014
1015 if (isELA()) {
1016 displayBip32InfoForELA();
1017 }
ebd8d4e8
IC		 1018 }
1019
1020 function displayAddresses(start, total) {
40892aba
IC		 1021 generationProcesses.push(new (function() {
1022
1023 var rows = [];
1024
1025 this.stop = function() {
1026 for (var i=0; i<rows.length; i++) {
1027 rows[i].shouldGenerate = false;
1028 }
0eda54f5 1029 hidePending();
40892aba
IC		 1030 }
1031
1032 for (var i=0; i<total; i++) {
1033 var index = i + start;
0eda54f5
IC		 1034 var isLast = i == total - 1;
1035 rows.push(new TableRow(index, isLast));
40892aba
IC		 1036 }
1037
1038 })());
ebd8d4e8
IC		 1039 }
1040
0fd67b59 1041 function segwitSelected() {
4e9b492c 1042 return bip49TabSelected() || bip84TabSelected() || bip141TabSelected();
c49e8812
IC		 1043 }
1044
1045 function p2wpkhSelected() {
4e9b492c
IC		 1046 return bip84TabSelected() ||
1047 bip141TabSelected() && DOM.bip141semantics.val() == "p2wpkh";
c49e8812
IC		 1048 }
1049
1050 function p2wpkhInP2shSelected() {
1051 return bip49TabSelected() ||
1052 (bip141TabSelected() && DOM.bip141semantics.val() == "p2wpkh-p2sh");
93c3ef47
IC		 1053 }
1054
5c203fab
IC		 1055 function p2wshSelected() {
1056 return bip141TabSelected() && DOM.bip141semantics.val() == "p2wsh";
1057 }
1058
1059 function p2wshInP2shSelected() {
1060 return (bip141TabSelected() && DOM.bip141semantics.val() == "p2wsh-p2sh");
1061 }
1062
0eda54f5 1063 function TableRow(index, isLast) {
a8c45487 1064
40892aba
IC		 1065 var self = this;
1066 this.shouldGenerate = true;
146e089e 1067 var useHardenedAddresses = DOM.hardenedAddresses.prop("checked");
0b39e9dc
IC		 1068 var useBip38 = DOM.useBip38.prop("checked");
1069 var bip38password = DOM.bip38Password.val();
0fd67b59
IC		 1070 var isSegwit = segwitSelected();
1071 var segwitAvailable = networkHasSegwit();
c49e8812
IC		 1072 var isP2wpkh = p2wpkhSelected();
1073 var isP2wpkhInP2sh = p2wpkhInP2shSelected();
5c203fab
IC		 1074 var isP2wsh = p2wshSelected();
1075 var isP2wshInP2sh = p2wshInP2shSelected();
146e089e 1076
a8c45487
IC		 1077 function init() {
1078 calculateValues();
1079 }
1080
1081 function calculateValues() {
1082 setTimeout(function() {
40892aba
IC		 1083 if (!self.shouldGenerate) {
1084 return;
1085 }
cc61ec30 1086 // derive HDkey for this row of the table
a0091a40 1087 var key = "NA";
146e089e
IC		 1088 if (useHardenedAddresses) {
1089 key = bip32ExtendedKey.deriveHardened(index);
1090 }
1091 else {
1092 key = bip32ExtendedKey.derive(index);
1093 }
cc61ec30
IC		 1094 // bip38 requires uncompressed keys
1095 // see https://github.com/iancoleman/bip39/issues/140#issuecomment-352164035
1096 var keyPair = key.keyPair;
1097 var useUncompressed = useBip38;
1098 if (useUncompressed) {
22f87669 1099 keyPair = new libs.bitcoin.ECPair(keyPair.d, null, { network: network, compressed: false });
76120cb0 1100 if(isGRS())
22f87669 1101 keyPair = new libs.groestlcoinjs.ECPair(keyPair.d, null, { network: network, compressed: false });
76120cb0 1102
cc61ec30
IC		 1103 }
1104 // get address
1105 var address = keyPair.getAddress().toString();
1106 // get privkey
1107 var hasPrivkey = !key.isNeutered();
ba3cb9ec 1108 var privkey = "NA";
cc61ec30 1109 if (hasPrivkey) {
29c30bf3 1110 privkey = keyPair.toWIF();
cc61ec30
IC		 1111 // BIP38 encode private key if required
1112 if (useBip38) {
75138bee 1113 if(isGRS())
22f87669 1114 privkey = libs.groestlcoinjsBip38.encrypt(keyPair.d.toBuffer(), false, bip38password, function(p) {
76120cb0
H		 1115 console.log("Progressed " + p.percent.toFixed(1) + "% for index " + index);
1116 }, null, networks[DOM.network.val()].name.includes("Testnet"));
1117 else
22f87669 1118 privkey = libs.bip38.encrypt(keyPair.d.toBuffer(), false, bip38password, function(p) {
76120cb0
H		 1119 console.log("Progressed " + p.percent.toFixed(1) + "% for index " + index);
1120 });
cc61ec30 1121 }
ba3cb9ec 1122 }
cc61ec30
IC		 1123 // get pubkey
1124 var pubkey = keyPair.getPublicKeyBuffer().toString('hex');
38523d36 1125 var indexText = getDerivationPath() + "/" + index;
146e089e
IC		 1126 if (useHardenedAddresses) {
1127 indexText = indexText + "'";
1128 }
0edac945 1129 // Ethereum values are different
44e705cd 1130 if (networkIsEthereum()) {
4dfc681f
ML		 1131 var pubkeyBuffer = keyPair.getPublicKeyBuffer();
1132 var ethPubkey = libs.ethUtil.importPublic(pubkeyBuffer);
1133 var addressBuffer = libs.ethUtil.publicToAddress(ethPubkey);
49b21f12 1134 var hexAddress = addressBuffer.toString('hex');
22f87669
IC		 1135 var checksumAddress = libs.ethUtil.toChecksumAddress(hexAddress);
1136 address = libs.ethUtil.addHexPrefix(checksumAddress);
22f87669 1137 pubkey = libs.ethUtil.addHexPrefix(pubkey);
dd496c82
IC		 1138 if (hasPrivkey) {
1139 privkey = libs.ethUtil.bufferToHex(keyPair.d.toBuffer());
1140 }
0edac945 1141 }
c2e4f938 1142
a823e526 1143 // RSK values are different
1144 if (networkIsRsk()) {
1145 var pubkeyBuffer = keyPair.getPublicKeyBuffer();
1146 var ethPubkey = libs.ethUtil.importPublic(pubkeyBuffer);
1147 var addressBuffer = libs.ethUtil.publicToAddress(ethPubkey);
1148 var hexAddress = addressBuffer.toString('hex');
1149 // Use chainId based on selected network
1150 // Ref: https://developers.rsk.co/rsk/architecture/account-based/#chainid
1151 var chainId;
1152 var rskNetworkName = networks[DOM.network.val()].name;
1153 switch (rskNetworkName) {
1154 case "R-BTC - RSK":
1155 chainId = 30;
1156 break;
1157 case "tR-BTC - RSK Testnet":
1158 chainId = 31;
1159 break;
1160 default:
1161 chainId = null;
1162 }
1163 var checksumAddress = toChecksumAddressForRsk(hexAddress, chainId);
1164 address = libs.ethUtil.addHexPrefix(checksumAddress);
1165 pubkey = libs.ethUtil.addHexPrefix(pubkey);
1166 if (hasPrivkey) {
1167 privkey = libs.ethUtil.bufferToHex(keyPair.d.toBuffer());
1168 }
1169 }
1170
0e1fd953
JK		 1171 // Handshake values are different
1172 if (networks[DOM.network.val()].name == "HNS - Handshake") {
1173 var ring = libs.handshake.KeyRing.fromPublic(keyPair.getPublicKeyBuffer())
1174 address = ring.getAddress().toString();
1175 }
bf528f65 1176
8ffa333b
SÖ		 1177 // Stellar is different
1178 if (networks[DOM.network.val()].name == "XLM - Stellar") {
22c443df
SÖ		 1179 var purpose = parseIntNoNaN(DOM.bip44purpose.val(), 44);
1180 var coin = parseIntNoNaN(DOM.bip44coin.val(), 0);
1181 var path = "m/";
1182 path += purpose + "'/";
1183 path += coin + "'/" + index + "'";
22f87669 1184 var keypair = libs.stellarUtil.getKeypair(path, seed);
8ffa333b
SÖ		 1185 indexText = path;
1186 privkey = keypair.secret();
1187 pubkey = address = keypair.publicKey();
1188 }
7a113003 1189 if ((networks[DOM.network.val()].name == "NAS - Nebulas")) {
7a113003 1190 var privKeyBuffer = keyPair.d.toBuffer(32);
22f87669 1191 var nebulasAccount = libs.nebulas.Account.NewAccount();
491948db 1192 nebulasAccount.setPrivateKey(privKeyBuffer);
1193 address = nebulasAccount.getAddressString();
1194 privkey = nebulasAccount.getPrivateKeyString();
1195 pubkey = nebulasAccount.getPublicKeyString();
7a113003 1196 }
64a7d2aa 1197 // Ripple values are different
534481b6 1198 if (networks[DOM.network.val()].name == "XRP - Ripple") {
64a7d2aa 1199 privkey = convertRipplePriv(privkey);
1200 address = convertRippleAdrr(address);
1201 }
46a5338e
LL		 1202 // Jingtum values are different
1203 if (networks[DOM.network.val()].name == "SWTC - Jingtum") {
1204 privkey = convertJingtumPriv(privkey);
1205 address = convertJingtumAdrr(address);
1206 }
45e40c28
C		 1207 // CasinoCoin values are different
1208 if (networks[DOM.network.val()].name == "CSC - CasinoCoin") {
1209 privkey = convertCasinoCoinPriv(privkey);
1210 address = convertCasinoCoinAdrr(address);
1211 }
e0f91e20
IC		 1212 // Bitcoin Cash address format may vary
1213 if (networks[DOM.network.val()].name == "BCH - Bitcoin Cash") {
1214 var bchAddrType = DOM.bitcoinCashAddressType.filter(":checked").val();
1215 if (bchAddrType == "cashaddr") {
22f87669 1216 address = libs.bchaddr.toCashAddress(address);
e0f91e20
IC		 1217 }
1218 else if (bchAddrType == "bitpay") {
22f87669 1219 address = libs.bchaddr.toBitpayAddress(address);
e0f91e20
IC		 1220 }
1221 }
d0889ab9 1222 // Bitcoin Cash address format may vary
1223 if (networks[DOM.network.val()].name == "SLP - Simple Ledger Protocol") {
1224 var bchAddrType = DOM.bitcoinCashAddressType.filter(":checked").val();
1225 if (bchAddrType == "cashaddr") {
22f87669 1226 address = libs.bchaddrSlp.toSlpAddress(address);
d0889ab9 1227 }
1228 }
0fd67b59
IC		 1229 // Segwit addresses are different
1230 if (isSegwit) {
1231 if (!segwitAvailable) {
6c08f364
IC		 1232 return;
1233 }
c49e8812 1234 if (isP2wpkh) {
22f87669
IC		 1235 var keyhash = libs.bitcoin.crypto.hash160(key.getPublicKeyBuffer());
1236 var scriptpubkey = libs.bitcoin.script.witnessPubKeyHash.output.encode(keyhash);
1237 address = libs.bitcoin.address.fromOutputScript(scriptpubkey, network)
c49e8812
IC		 1238 }
1239 else if (isP2wpkhInP2sh) {
22f87669
IC		 1240 var keyhash = libs.bitcoin.crypto.hash160(key.getPublicKeyBuffer());
1241 var scriptsig = libs.bitcoin.script.witnessPubKeyHash.output.encode(keyhash);
1242 var addressbytes = libs.bitcoin.crypto.hash160(scriptsig);
1243 var scriptpubkey = libs.bitcoin.script.scriptHash.output.encode(addressbytes);
1244 address = libs.bitcoin.address.fromOutputScript(scriptpubkey, network)
c49e8812 1245 }
5c203fab 1246 else if (isP2wsh) {
22f87669 1247 // https://github.com/libs.bitcoinjs-lib/blob/v3.3.2/test/integration/addresses.js#L71
f7e9fdf0 1248 // This is a 1-of-1
22f87669
IC		 1249 var witnessScript = libs.bitcoin.script.multisig.output.encode(1, [key.getPublicKeyBuffer()]);
1250 var scriptPubKey = libs.bitcoin.script.witnessScriptHash.output.encode(libs.bitcoin.crypto.sha256(witnessScript));
1251 address = libs.bitcoin.address.fromOutputScript(scriptPubKey, network);
5c203fab
IC		 1252 }
1253 else if (isP2wshInP2sh) {
22f87669 1254 // https://github.com/libs.bitcoinjs-lib/blob/v3.3.2/test/integration/transactions.js#L183
f7e9fdf0 1255 // This is a 1-of-1
22f87669
IC		 1256 var witnessScript = libs.bitcoin.script.multisig.output.encode(1, [key.getPublicKeyBuffer()]);
1257 var redeemScript = libs.bitcoin.script.witnessScriptHash.output.encode(libs.bitcoin.crypto.sha256(witnessScript));
1258 var scriptPubKey = libs.bitcoin.script.scriptHash.output.encode(libs.bitcoin.crypto.hash160(redeemScript));
1259 address = libs.bitcoin.address.fromOutputScript(scriptPubKey, network)
5c203fab 1260 }
6c08f364 1261 }
b85da074 1262
bf13c95f 1263 if ((networks[DOM.network.val()].name == "CRW - Crown")) {
22f87669 1264 address = libs.bitcoin.networks.crown.toNewAddress(address);
bf13c95f 1265 }
b85da074 1266
7d68d547 1267 if (networks[DOM.network.val()].name == "EOS - EOSIO") {
3451d1a8 1268 address = ""
5c6e875f
JU		 1269 pubkey = EOSbufferToPublic(keyPair.getPublicKeyBuffer());
1270 privkey = EOSbufferToPrivate(keyPair.d.toBuffer(32));
3451d1a8 1271 }
82e3938a 1272
d1d8699f
SA		 1273 if (networks[DOM.network.val()].name == "FIO - Foundation for Interwallet Operability") {
1274 address = ""
1275 pubkey = FIObufferToPublic(keyPair.getPublicKeyBuffer());
1276 privkey = FIObufferToPrivate(keyPair.d.toBuffer(32));
1277 }
1278
76120cb0
H		 1279 //Groestlcoin Addresses are different
1280 if(isGRS()) {
1281
1282 if (isSegwit) {
1283 if (!segwitAvailable) {
1284 return;
1285 }
1286 if (isP2wpkh) {
22f87669 1287 address = libs.groestlcoinjs.address.fromOutputScript(scriptpubkey, network)
76120cb0
H		 1288 }
1289 else if (isP2wpkhInP2sh) {
22f87669 1290 address = libs.groestlcoinjs.address.fromOutputScript(scriptpubkey, network)
76120cb0 1291 }
75138bee 1292 }
76120cb0
H		 1293 //non-segwit addresses are handled by using groestlcoinjs for bip32RootKey
1294 }
1295
36523e0d
NJ		 1296 if (isELA()) {
1297 let elaAddress = calcAddressForELA(
1298 seed,
1299 parseIntNoNaN(DOM.bip44coin.val(), 0),
1300 parseIntNoNaN(DOM.bip44account.val(), 0),
1301 parseIntNoNaN(DOM.bip44change.val(), 0),
1302 index
1303 );
1304 address = elaAddress.address;
1305 privkey = elaAddress.privateKey;
1306 pubkey = elaAddress.publicKey;
1307 }
1308
1b12b2f5 1309 addAddressToList(indexText, address, pubkey, privkey);
0eda54f5
IC		 1310 if (isLast) {
1311 hidePending();
a78f4e28 1312 updateCsv();
0eda54f5 1313 }
a8c45487
IC		 1314 }, 50)
1315 }
1316
1317 init();
1318
1319 }
1320
ebd8d4e8 1321 function showMore() {
ebd8d4e8
IC		 1322 var rowsToAdd = parseInt(DOM.rowsToAdd.val());
1323 if (isNaN(rowsToAdd)) {
1324 rowsToAdd = 20;
1325 DOM.rowsToAdd.val("20");
1326 }
9183f9f6
IC		 1327 var start = parseInt(DOM.moreRowsStartIndex.val())
1328 if (isNaN(start)) {
1329 start = lastIndexInTable() + 1;
1330 }
1331 else {
1332 var newStart = start + rowsToAdd;
1333 DOM.moreRowsStartIndex.val(newStart);
1334 }
ebd8d4e8
IC		 1335 if (rowsToAdd > 200) {
1336 var msg = "Generating " + rowsToAdd + " rows could take a while. ";
1337 msg += "Do you want to continue?";
1338 if (!confirm(msg)) {
1339 return;
1340 }
1341 }
ebd8d4e8 1342 displayAddresses(start, rowsToAdd);
ebd8d4e8
IC		 1343 }
1344
1345 function clearDisplay() {
1346 clearAddressesList();
fa2e4e93 1347 clearKeys();
ebd8d4e8
IC		 1348 hideValidationError();
1349 }
1350
1351 function clearAddressesList() {
1352 DOM.addresses.empty();
a78f4e28 1353 DOM.csv.val("");
40892aba
IC		 1354 stopGenerating();
1355 }
1356
1357 function stopGenerating() {
1358 while (generationProcesses.length > 0) {
1359 var generation = generationProcesses.shift();
1360 generation.stop();
1361 }
ebd8d4e8
IC		 1362 }
1363
fa2e4e93
IC		 1364 function clearKeys() {
1365 clearRootKey();
1366 clearDerivedKeys();
1367 }
1368
1369 function clearRootKey() {
ebd8d4e8 1370 DOM.rootKey.val("");
fa2e4e93
IC		 1371 }
1372
1373 function clearDerivedKeys() {
ebd8d4e8
IC		 1374 DOM.extendedPrivKey.val("");
1375 DOM.extendedPubKey.val("");
fa2e4e93
IC		 1376 DOM.bip44accountXprv.val("");
1377 DOM.bip44accountXpub.val("");
ebd8d4e8
IC		 1378 }
1379
1b12b2f5 1380 function addAddressToList(indexText, address, pubkey, privkey) {
ebd8d4e8 1381 var row = $(addressRowTemplate.html());
700901cd
IC		 1382 // Elements
1383 var indexCell = row.find(".index span");
1384 var addressCell = row.find(".address span");
1b12b2f5 1385 var pubkeyCell = row.find(".pubkey span");
700901cd
IC		 1386 var privkeyCell = row.find(".privkey span");
1387 // Content
ae30fed8 1388 indexCell.text(indexText);
700901cd 1389 addressCell.text(address);
1b12b2f5 1390 pubkeyCell.text(pubkey);
700901cd
IC		 1391 privkeyCell.text(privkey);
1392 // Visibility
1393 if (!showIndex) {
1394 indexCell.addClass("invisible");
1395 }
1396 if (!showAddress) {
1397 addressCell.addClass("invisible");
1398 }
1b12b2f5
IC		 1399 if (!showPubKey) {
1400 pubkeyCell.addClass("invisible");
1401 }
700901cd 1402 if (!showPrivKey) {
6d628db7 1403 privkeyCell.addClass("invisible");
700901cd 1404 }
ebd8d4e8 1405 DOM.addresses.append(row);
e00964cc
IC		 1406 var rowShowQrEls = row.find("[data-show-qr]");
1407 setQrEvents(rowShowQrEls);
ebd8d4e8
IC		 1408 }
1409
1410 function hasStrongRandom() {
1411 return 'crypto' in window && window['crypto'] !== null;
1412 }
1413
1414 function disableForms() {
1415 $("form").on("submit", function(e) {
1416 e.preventDefault();
1417 });
1418 }
1419
ebd8d4e8
IC		 1420 function parseIntNoNaN(val, defaultVal) {
1421 var v = parseInt(val);
1422 if (isNaN(v)) {
1423 return defaultVal;
1424 }
1425 return v;
1426 }
1427
1428 function showPending() {
1429 DOM.feedback
1430 .text("Calculating...")
1431 .show();
1432 }
1433
563e401a 1434 function findNearestWord(word) {
5ee7bb9e
IC		 1435 var language = getLanguage();
1436 var words = WORDLISTS[language];
563e401a
IC		 1437 var minDistance = 99;
1438 var closestWord = words[0];
1439 for (var i=0; i<words.length; i++) {
1440 var comparedTo = words[i];
6ea15134
IC		 1441 if (comparedTo.indexOf(word) == 0) {
1442 return comparedTo;
1443 }
22f87669 1444 var distance = libs.levenshtein.get(word, comparedTo);
563e401a
IC		 1445 if (distance < minDistance) {
1446 closestWord = comparedTo;
1447 minDistance = distance;
1448 }
1449 }
1450 return closestWord;
1451 }
1452
ebd8d4e8
IC		 1453 function hidePending() {
1454 DOM.feedback
1455 .text("")
1456 .hide();
1457 }
1458
7f15cb6e
IC		 1459 function populateNetworkSelect() {
1460 for (var i=0; i<networks.length; i++) {
1461 var network = networks[i];
1462 var option = $("<option>");
1463 option.attr("value", i);
1464 option.text(network.name);
7b742f87
IC		 1465 if (network.name == "BTC - Bitcoin") {
1466 option.prop("selected", true);
1467 }
7f15cb6e
IC		 1468 DOM.phraseNetwork.append(option);
1469 }
1470 }
29bf60f5 1471
b4fd763c
AG		 1472 function populateClientSelect() {
1473 for (var i=0; i<clients.length; i++) {
1474 var client = clients[i];
1475 var option = $("<option>");
1476 option.attr("value", i);
1477 option.text(client.name);
29bf60f5 1478 DOM.bip32Client.append(option);
b4fd763c
AG		 1479 }
1480 }
7f15cb6e 1481
5ee7bb9e
IC		 1482 function getLanguage() {
1483 var defaultLanguage = "english";
1484 // Try to get from existing phrase
1485 var language = getLanguageFromPhrase();
1486 // Try to get from url if not from phrase
1487 if (language.length == 0) {
1488 language = getLanguageFromUrl();
1489 }
1490 // Default to English if no other option
1491 if (language.length == 0) {
1492 language = defaultLanguage;
1493 }
1494 return language;
1495 }
1496
1497 function getLanguageFromPhrase(phrase) {
1498 // Check if how many words from existing phrase match a language.
1499 var language = "";
1500 if (!phrase) {
1501 phrase = DOM.phrase.val();
1502 }
1503 if (phrase.length > 0) {
1504 var words = phraseToWordArray(phrase);
1505 var languageMatches = {};
1506 for (l in WORDLISTS) {
1507 // Track how many words match in this language
1508 languageMatches[l] = 0;
1509 for (var i=0; i<words.length; i++) {
1510 var wordInLanguage = WORDLISTS[l].indexOf(words[i]) > -1;
1511 if (wordInLanguage) {
1512 languageMatches[l]++;
1513 }
1514 }
1515 // Find languages with most word matches.
1516 // This is made difficult due to commonalities between Chinese
1517 // simplified vs traditional.
1518 var mostMatches = 0;
1519 var mostMatchedLanguages = [];
1520 for (var l in languageMatches) {
1521 var numMatches = languageMatches[l];
1522 if (numMatches > mostMatches) {
1523 mostMatches = numMatches;
1524 mostMatchedLanguages = [l];
1525 }
1526 else if (numMatches == mostMatches) {
1527 mostMatchedLanguages.push(l);
1528 }
1529 }
1530 }
1531 if (mostMatchedLanguages.length > 0) {
1532 // Use first language and warn if multiple detected
1533 language = mostMatchedLanguages[0];
1534 if (mostMatchedLanguages.length > 1) {
1535 console.warn("Multiple possible languages");
1536 console.warn(mostMatchedLanguages);
1537 }
1538 }
1539 }
1540 return language;
1541 }
1542
1543 function getLanguageFromUrl() {
c6624d51
IC		 1544 for (var language in WORDLISTS) {
1545 if (window.location.hash.indexOf(language) > -1) {
1546 return language;
1547 }
1548 }
1549 return "";
5ee7bb9e
IC		 1550 }
1551
1552 function setMnemonicLanguage() {
1553 var language = getLanguage();
1554 // Load the bip39 mnemonic generator for this language if required
1555 if (!(language in mnemonics)) {
1556 mnemonics[language] = new Mnemonic(language);
1557 }
1558 mnemonic = mnemonics[language];
1559 }
1560
1561 function convertPhraseToNewLanguage() {
1562 var oldLanguage = getLanguageFromPhrase();
1563 var newLanguage = getLanguageFromUrl();
1564 var oldPhrase = DOM.phrase.val();
1565 var oldWords = phraseToWordArray(oldPhrase);
1566 var newWords = [];
1567 for (var i=0; i<oldWords.length; i++) {
1568 var oldWord = oldWords[i];
1569 var index = WORDLISTS[oldLanguage].indexOf(oldWord);
1570 var newWord = WORDLISTS[newLanguage][index];
1571 newWords.push(newWord);
1572 }
1573 newPhrase = wordArrayToPhrase(newWords);
1574 return newPhrase;
1575 }
1576
1577 // TODO look at jsbip39 - mnemonic.splitWords
1578 function phraseToWordArray(phrase) {
1579 var words = phrase.split(/\s/g);
1580 var noBlanks = [];
1581 for (var i=0; i<words.length; i++) {
1582 var word = words[i];
1583 if (word.length > 0) {
1584 noBlanks.push(word);
1585 }
1586 }
1587 return noBlanks;
1588 }
1589
1590 // TODO look at jsbip39 - mnemonic.joinWords
1591 function wordArrayToPhrase(words) {
1592 var phrase = words.join(" ");
1593 var language = getLanguageFromPhrase(phrase);
956e44ef 1594 if (language == "japanese") {
5ee7bb9e
IC		 1595 phrase = words.join("\u3000");
1596 }
1597 return phrase;
1598 }
96ee8ab0
IC		 1599
1600 function writeSplitPhrase(phrase) {
d93f2ba9
IC		 1601 var wordCount = phrase.split(/\s/g).length;
1602 var left=[];
1603 for (var i=0;i<wordCount;i++) left.push(i);
1604 var group=[[],[],[]],
1605 groupI=-1;
1606 var seed = Math.abs(sjcl.hash.sha256.hash(phrase)[0])% 2147483647;
1607 while (left.length>0) {
1608 groupI=(groupI+1)%3;
1609 seed = seed * 16807 % 2147483647;
1610 var selected=Math.floor(left.length*(seed - 1) / 2147483646);
1611 group[groupI].push(left[selected]);
1612 left.splice(selected,1);
1613 }
1614 var cards=[phrase.split(/\s/g),phrase.split(/\s/g),phrase.split(/\s/g)];
1615 for (var i=0;i<3;i++) {
1616 for (var ii=0;ii<wordCount/3;ii++) cards[i][group[i][ii]]='XXXX';
1617 cards[i]='Card '+(i+1)+': '+wordArrayToPhrase(cards[i]);
1618 }
f8fae68e 1619 DOM.phraseSplit.val(cards.join("\r\n"));
d93f2ba9
IC		 1620 var triesPerSecond=10000000000;
1621 var hackTime=Math.pow(2,wordCount*10/3)/triesPerSecond;
ea2cb91a 1622 var displayRedText = false;
96ee8ab0
IC		 1623 if (hackTime<1) {
1624 hackTime="<1 second";
ea2cb91a 1625 displayRedText = true;
96ee8ab0
IC		 1626 } else if (hackTime<86400) {
1627 hackTime=Math.floor(hackTime)+" seconds";
ea2cb91a 1628 displayRedText = true;
96ee8ab0
IC		 1629 } else if(hackTime<31557600) {
1630 hackTime=Math.floor(hackTime/86400)+" days";
ea2cb91a 1631 displayRedText = true;
96ee8ab0
IC		 1632 } else {
1633 hackTime=Math.floor(hackTime/31557600)+" years";
1634 }
1635 DOM.phraseSplitWarn.html("Time to hack with only one card: "+hackTime);
ea2cb91a
IC		 1636 if (displayRedText) {
1637 DOM.phraseSplitWarn.addClass("text-danger");
1638 } else {
1639 DOM.phraseSplitWarn.removeClass("text-danger");
1640 }
96ee8ab0 1641 }
5ee7bb9e 1642
c6624d51
IC		 1643 function isUsingOwnEntropy() {
1644 return DOM.useEntropy.prop("checked");
1645 }
1646
1647 function setMnemonicFromEntropy() {
0a84fe6a 1648 clearEntropyFeedback();
057722b0 1649 // Get entropy value
c6624d51 1650 var entropyStr = DOM.entropy.val();
057722b0 1651 // Work out minimum base for entropy
516c16d7
IC		 1652 var entropy = null;
1653 if (entropyTypeAutoDetect) {
1654 entropy = Entropy.fromString(entropyStr);
1655 }
1656 else {
1657 let base = DOM.entropyTypeInputs.filter(":checked").val();
1658 entropy = Entropy.fromString(entropyStr, base);
1659 }
057722b0 1660 if (entropy.binaryStr.length == 0) {
c6624d51
IC		 1661 return;
1662 }
1663 // Show entropy details
1cf1bbaf 1664 showEntropyFeedback(entropy);
3599674d
IC		 1665 // Use entropy hash if not using raw entropy
1666 var bits = entropy.binaryStr;
1667 var mnemonicLength = DOM.entropyMnemonicLength.val();
1668 if (mnemonicLength != "raw") {
1669 // Get bits by hashing entropy with SHA256
1670 var hash = sjcl.hash.sha256.hash(entropy.cleanStr);
1671 var hex = sjcl.codec.hex.fromBits(hash);
22f87669 1672 bits = libs.BigInteger.BigInteger.parse(hex, 16).toString(2);
53aaab27 1673 while (bits.length % 256 != 0) {
3599674d
IC		 1674 bits = "0" + bits;
1675 }
1676 // Truncate hash to suit number of words
1677 mnemonicLength = parseInt(mnemonicLength);
1678 var numberOfBits = 32 * mnemonicLength / 3;
1679 bits = bits.substring(0, numberOfBits);
645945a0
IC		 1680 // show warning for weak entropy override
1681 if (mnemonicLength / 3 * 32 > entropy.binaryStr.length) {
1682 DOM.entropyWeakEntropyOverrideWarning.removeClass("hidden");
1683 }
1684 else {
1685 DOM.entropyWeakEntropyOverrideWarning.addClass("hidden");
1686 }
1687 }
1688 else {
1689 // hide warning for weak entropy override
1690 DOM.entropyWeakEntropyOverrideWarning.addClass("hidden");
3599674d 1691 }
c6624d51 1692 // Discard trailing entropy
3599674d 1693 var bitsToUse = Math.floor(bits.length / 32) * 32;
d6fd8ebf
IC		 1694 var start = bits.length - bitsToUse;
1695 var binaryStr = bits.substring(start);
c6624d51
IC		 1696 // Convert entropy string to numeric array
1697 var entropyArr = [];
adc8ce12
IC		 1698 for (var i=0; i<binaryStr.length / 8; i++) {
1699 var byteAsBits = binaryStr.substring(i*8, i*8+8);
1700 var entropyByte = parseInt(byteAsBits, 2);
c6624d51
IC		 1701 entropyArr.push(entropyByte)
1702 }
1703 // Convert entropy array to mnemonic
1704 var phrase = mnemonic.toMnemonic(entropyArr);
1705 // Set the mnemonic in the UI
1706 DOM.phrase.val(phrase);
96ee8ab0 1707 writeSplitPhrase(phrase);
74ab4cbe
IC		 1708 // Show the word indexes
1709 showWordIndexes();
09d63290
IC		 1710 // Show the checksum
1711 showChecksum();
c6624d51
IC		 1712 }
1713
0a84fe6a 1714 function clearEntropyFeedback() {
20f459ce 1715 DOM.entropyCrackTime.text("...");
1cf1bbaf 1716 DOM.entropyType.text("");
0a84fe6a
IC		 1717 DOM.entropyWordCount.text("0");
1718 DOM.entropyEventCount.text("0");
1719 DOM.entropyBitsPerEvent.text("0");
1720 DOM.entropyBits.text("0");
1721 DOM.entropyFiltered.html("&nbsp;");
1722 DOM.entropyBinary.html("&nbsp;");
c6624d51
IC		 1723 }
1724
1cf1bbaf 1725 function showEntropyFeedback(entropy) {
6422c1cd 1726 var numberOfBits = entropy.binaryStr.length;
20f459ce 1727 var timeToCrack = "unknown";
9bc39377 1728 try {
22f87669 1729 var z = libs.zxcvbn(entropy.base.parts.join(""));
20f459ce
IC		 1730 timeToCrack = z.crack_times_display.offline_fast_hashing_1e10_per_second;
1731 if (z.feedback.warning != "") {
1732 timeToCrack = timeToCrack + " - " + z.feedback.warning;
1733 };
9bc39377
IC		 1734 }
1735 catch (e) {
9bc39377
IC		 1736 console.log("Error detecting entropy strength with zxcvbn:");
1737 console.log(e);
b299a6a7 1738 }
391c7f26 1739 var entropyTypeStr = getEntropyTypeStr(entropy);
516c16d7
IC		 1740 DOM.entropyTypeInputs.attr("checked", false);
1741 DOM.entropyTypeInputs.filter("[value='" + entropyTypeStr + "']").attr("checked", true);
6422c1cd 1742 var wordCount = Math.floor(numberOfBits / 32) * 3;
94959756 1743 var bitsPerEvent = entropy.bitsPerEvent.toFixed(2);
f8ca25c3 1744 var spacedBinaryStr = addSpacesEveryElevenBits(entropy.binaryStr);
b54c1218 1745 DOM.entropyFiltered.html(entropy.cleanHtml);
391c7f26 1746 DOM.entropyType.text(entropyTypeStr);
20f459ce 1747 DOM.entropyCrackTime.text(timeToCrack);
1cf1bbaf 1748 DOM.entropyEventCount.text(entropy.base.ints.length);
6422c1cd 1749 DOM.entropyBits.text(numberOfBits);
0a84fe6a 1750 DOM.entropyWordCount.text(wordCount);
d6cade86 1751 DOM.entropyBinary.text(spacedBinaryStr);
6422c1cd 1752 DOM.entropyBitsPerEvent.text(bitsPerEvent);
ee0981f1
IC		 1753 // detect and warn of filtering
1754 var rawNoSpaces = DOM.entropy.val().replace(/\s/g, "");
1755 var cleanNoSpaces = entropy.cleanStr.replace(/\s/g, "");
1756 var isFiltered = rawNoSpaces.length != cleanNoSpaces.length;
1757 if (isFiltered) {
1758 DOM.entropyFilterWarning.removeClass('hidden');
1759 }
1760 else {
1761 DOM.entropyFilterWarning.addClass('hidden');
1762 }
02f05d3e
IC		 1763 }
1764
391c7f26
IC		 1765 function getEntropyTypeStr(entropy) {
1766 var typeStr = entropy.base.str;
1767 // Add some detail if these are cards
1768 if (entropy.base.asInt == 52) {
1769 var cardDetail = []; // array of message strings
1770 // Detect duplicates
1771 var dupes = [];
1772 var dupeTracker = {};
1773 for (var i=0; i<entropy.base.parts.length; i++) {
1774 var card = entropy.base.parts[i];
5c653a12
IC		 1775 var cardUpper = card.toUpperCase();
1776 if (cardUpper in dupeTracker) {
391c7f26
IC		 1777 dupes.push(card);
1778 }
5c653a12 1779 dupeTracker[cardUpper] = true;
391c7f26
IC		 1780 }
1781 if (dupes.length > 0) {
1782 var dupeWord = "duplicates";
1783 if (dupes.length == 1) {
1784 dupeWord = "duplicate";
1785 }
1786 var msg = dupes.length + " " + dupeWord + ": " + dupes.slice(0,3).join(" ");
1787 if (dupes.length > 3) {
1788 msg += "...";
1789 }
1790 cardDetail.push(msg);
1791 }
1792 // Detect full deck
1793 var uniqueCards = [];
1794 for (var uniqueCard in dupeTracker) {
1795 uniqueCards.push(uniqueCard);
1796 }
1797 if (uniqueCards.length == 52) {
1798 cardDetail.unshift("full deck");
1799 }
bbc29c80
IC		 1800 // Detect missing cards
1801 var values = "A23456789TJQK";
1802 var suits = "CDHS";
1803 var missingCards = [];
1804 for (var i=0; i<suits.length; i++) {
1805 for (var j=0; j<values.length; j++) {
1806 var card = values[j] + suits[i];
1807 if (!(card in dupeTracker)) {
1808 missingCards.push(card);
1809 }
1810 }
1811 }
1812 // Display missing cards if six or less, ie clearly going for full deck
1813 if (missingCards.length > 0 && missingCards.length <= 6) {
1814 var msg = missingCards.length + " missing: " + missingCards.slice(0,3).join(" ");
1815 if (missingCards.length > 3) {
1816 msg += "...";
1817 }
1818 cardDetail.push(msg);
1819 }
391c7f26
IC		 1820 // Add card details to typeStr
1821 if (cardDetail.length > 0) {
1822 typeStr += " (" + cardDetail.join(", ") + ")";
1823 }
1824 }
1825 return typeStr;
1826 }
1827
e00964cc
IC		 1828 function setQrEvents(els) {
1829 els.on("mouseenter", createQr);
1830 els.on("mouseleave", destroyQr);
1831 els.on("click", toggleQr);
1832 }
1833
1834 function createQr(e) {
1835 var content = e.target.textContent || e.target.value;
1836 if (content) {
22f87669 1837 var qrEl = libs.kjua({
9225b805
IC		 1838 text: content,
1839 render: "canvas",
1840 size: 310,
1841 ecLevel: 'H',
1842 });
1843 DOM.qrImage.append(qrEl);
e00964cc 1844 if (!showQr) {
97811c29
IC		 1845 DOM.qrHider.addClass("hidden");
1846 }
1847 else {
1848 DOM.qrHider.removeClass("hidden");
e00964cc
IC		 1849 }
1850 DOM.qrContainer.removeClass("hidden");
1851 }
1852 }
1853
1854 function destroyQr() {
1855 DOM.qrImage.text("");
1856 DOM.qrContainer.addClass("hidden");
1857 }
1858
1859 function toggleQr() {
1860 showQr = !showQr;
97811c29 1861 DOM.qrHider.toggleClass("hidden");
e00964cc
IC		 1862 DOM.qrHint.toggleClass("hidden");
1863 }
1864
32fab2c3
IC		 1865 function bip44TabSelected() {
1866 return DOM.bip44tab.hasClass("active");
1867 }
1868
1869 function bip32TabSelected() {
1870 return DOM.bip32tab.hasClass("active");
1871 }
1872
44e705cd
IB		 1873 function networkIsEthereum() {
1874 var name = networks[DOM.network.val()].name;
1875 return (name == "ETH - Ethereum")
1876 || (name == "ETC - Ethereum Classic")
90929701 1877 || (name == "EWT - EnergyWeb")
44e705cd
IB		 1878 || (name == "PIRL - Pirl")
1879 || (name == "MIX - MIX")
46a5338e 1880 || (name == "MOAC - MOAC")
44e705cd
IB		 1881 || (name == "MUSIC - Musicoin")
1882 || (name == "POA - Poa")
1883 || (name == "EXP - Expanse")
1884 || (name == "CLO - Callisto")
1885 || (name == "DXN - DEXON")
1886 || (name == "ELLA - Ellaism")
1887 || (name == "ESN - Ethersocial Network")
1888 || (name == "VET - VeChain")
8131a071 1889 || (name == "ERE - EtherCore")
995bc587 1890 || (name == "BSC - Binance Smart Chain")
44e705cd
IB		 1891 }
1892
a823e526 1893 function networkIsRsk() {
1894 var name = networks[DOM.network.val()].name;
1895 return (name == "R-BTC - RSK")
1896 || (name == "tR-BTC - RSK Testnet");
1897 }
1898
0fd67b59 1899 function networkHasSegwit() {
c147cb5e
IC		 1900 var n = network;
1901 if ("baseNetwork" in network) {
22f87669 1902 n = libs.bitcoin.networks[network.baseNetwork];
c147cb5e
IC		 1903 }
1904 // check if only p2wpkh params are required
1905 if (p2wpkhSelected()) {
1906 return "p2wpkh" in n;
1907 }
1908 // check if only p2wpkh-in-p2sh params are required
1909 else if (p2wpkhInP2shSelected()) {
1910 return "p2wpkhInP2sh" in n;
1911 }
1912 // require both if it's unclear which params are required
1913 return "p2wpkh" in n && "p2wpkhInP2sh" in n;
6c08f364
IC		 1914 }
1915
1916 function bip49TabSelected() {
1917 return DOM.bip49tab.hasClass("active");
1918 }
1919
4e9b492c
IC		 1920 function bip84TabSelected() {
1921 return DOM.bip84tab.hasClass("active");
1922 }
1923
c49e8812
IC		 1924 function bip141TabSelected() {
1925 return DOM.bip141tab.hasClass("active");
1926 }
1927
6c08f364
IC		 1928 function setHdCoin(coinValue) {
1929 DOM.bip44coin.val(coinValue);
1930 DOM.bip49coin.val(coinValue);
4e9b492c 1931 DOM.bip84coin.val(coinValue);
6c08f364
IC		 1932 }
1933
0fd67b59 1934 function showSegwitAvailable() {
6c08f364
IC		 1935 DOM.bip49unavailable.addClass("hidden");
1936 DOM.bip49available.removeClass("hidden");
bddd5d9f
IC		 1937 DOM.bip84unavailable.addClass("hidden");
1938 DOM.bip84available.removeClass("hidden");
c49e8812
IC		 1939 DOM.bip141unavailable.addClass("hidden");
1940 DOM.bip141available.removeClass("hidden");
6c08f364
IC		 1941 }
1942
0fd67b59 1943 function showSegwitUnavailable() {
6c08f364
IC		 1944 DOM.bip49available.addClass("hidden");
1945 DOM.bip49unavailable.removeClass("hidden");
bddd5d9f
IC		 1946 DOM.bip84available.addClass("hidden");
1947 DOM.bip84unavailable.removeClass("hidden");
c49e8812
IC		 1948 DOM.bip141available.addClass("hidden");
1949 DOM.bip141unavailable.removeClass("hidden");
6c08f364
IC		 1950 }
1951
0fd67b59
IC		 1952 function adjustNetworkForSegwit() {
1953 // If segwit is selected the xpub/xprv prefixes need to be adjusted
93c3ef47
IC		 1954 // to avoid accidentally importing BIP49 xpub to BIP44 watch only
1955 // wallet.
1956 // See https://github.com/iancoleman/bip39/issues/125
c49e8812
IC		 1957 var segwitNetworks = null;
1958 // if a segwit network is alread selected, need to use base network to
1959 // look up new parameters
1960 if ("baseNetwork" in network) {
22f87669 1961 network = libs.bitcoin.networks[network.baseNetwork];
c49e8812
IC		 1962 }
1963 // choose the right segwit params
1964 if (p2wpkhSelected() && "p2wpkh" in network) {
1965 network = network.p2wpkh;
1966 }
1967 else if (p2wpkhInP2shSelected() && "p2wpkhInP2sh" in network) {
1968 network = network.p2wpkhInP2sh;
93c3ef47 1969 }
5c203fab
IC		 1970 else if (p2wshSelected() && "p2wsh" in network) {
1971 network = network.p2wsh;
1972 }
1973 else if (p2wshInP2shSelected() && "p2wshInP2sh" in network) {
1974 network = network.p2wshInP2sh;
1975 }
93c3ef47
IC		 1976 }
1977
9183f9f6
IC		 1978 function lastIndexInTable() {
1979 var pathText = DOM.addresses.find(".index").last().text();
1980 var pathBits = pathText.split("/");
1981 var lastBit = pathBits[pathBits.length-1];
1982 var lastBitClean = lastBit.replace("'", "");
1983 return parseInt(lastBitClean);
1984 }
1985
74ab4cbe
IC		 1986 function uint8ArrayToHex(a) {
1987 var s = ""
1988 for (var i=0; i<a.length; i++) {
1989 var h = a[i].toString(16);
1990 while (h.length < 2) {
1991 h = "0" + h;
1992 }
1993 s = s + h;
1994 }
1995 return s;
1996 }
1997
1998 function showWordIndexes() {
1999 var phrase = DOM.phrase.val();
2000 var words = phraseToWordArray(phrase);
2001 var wordIndexes = [];
2002 var language = getLanguage();
2003 for (var i=0; i<words.length; i++) {
2004 var word = words[i];
2005 var wordIndex = WORDLISTS[language].indexOf(word);
2006 wordIndexes.push(wordIndex);
2007 }
2008 var wordIndexesStr = wordIndexes.join(", ");
2009 DOM.entropyWordIndexes.text(wordIndexesStr);
2010 }
a78f4e28 2011
09d63290
IC		 2012 function showChecksum() {
2013 var phrase = DOM.phrase.val();
2014 var words = phraseToWordArray(phrase);
2015 var checksumBitlength = words.length / 3;
2016 var checksum = "";
2017 var binaryStr = "";
2018 var language = getLanguage();
2019 for (var i=words.length-1; i>=0; i--) {
2020 var word = words[i];
2021 var wordIndex = WORDLISTS[language].indexOf(word);
2022 var wordBinary = wordIndex.toString(2);
2023 while (wordBinary.length < 11) {
2024 wordBinary = "0" + wordBinary;
2025 }
2026 var binaryStr = wordBinary + binaryStr;
2027 if (binaryStr.length >= checksumBitlength) {
2028 var start = binaryStr.length - checksumBitlength;
2029 var end = binaryStr.length;
2030 checksum = binaryStr.substring(start, end);
f8ca25c3
IC		 2031 // add spaces so the last group is 11 bits, not the first
2032 checksum = checksum.split("").reverse().join("")
2033 checksum = addSpacesEveryElevenBits(checksum);
2034 checksum = checksum.split("").reverse().join("")
2035 break;
09d63290
IC		 2036 }
2037 }
2038 DOM.entropyChecksum.text(checksum);
2039 }
2040
a78f4e28
IC		 2041 function updateCsv() {
2042 var tableCsv = "path,address,public key,private key\n";
2043 var rows = DOM.addresses.find("tr");
2044 for (var i=0; i<rows.length; i++) {
2045 var row = $(rows[i]);
2046 var cells = row.find("td");
2047 for (var j=0; j<cells.length; j++) {
2048 var cell = $(cells[j]);
2049 if (!cell.children().hasClass("invisible")) {
2050 tableCsv = tableCsv + cell.text();
2051 }
2052 if (j != cells.length - 1) {
2053 tableCsv = tableCsv + ",";
2054 }
2055 }
2056 tableCsv = tableCsv + "\n";
2057 }
2058 DOM.csv.val(tableCsv);
2059 }
74ab4cbe 2060
f8ca25c3
IC		 2061 function addSpacesEveryElevenBits(binaryStr) {
2062 return binaryStr.match(/.{1,11}/g).join(" ");
2063 }
2064
7f15cb6e 2065 var networks = [
85f762c9 2066 {
2067 name: "AC - Asiacoin",
85f762c9 2068 onSelect: function() {
22f87669 2069 network = libs.bitcoin.networks.asiacoin;
85f762c9 2070 setHdCoin(51);
2071 },
2072 },
2073 {
2074 name: "ACC - Adcoin",
85f762c9 2075 onSelect: function() {
22f87669 2076 network = libs.bitcoin.networks.adcoin;
85f762c9 2077 setHdCoin(161);
2078 },
2079 },
46054e44
OS		 2080 {
2081 name: "AGM - Argoneum",
2082 onSelect: function() {
2083 network = libs.bitcoin.networks.argoneum;
2084 setHdCoin(421);
2085 },
2086 },
31264e8b
PT		 2087 {
2088 name: "ARYA - Aryacoin",
2089 onSelect: function() {
22f87669 2090 network = libs.bitcoin.networks.aryacoin;
31264e8b
PT		 2091 setHdCoin(357);
2092 },
2093 },
85f762c9 2094 {
2095 name: "AUR - Auroracoin",
85f762c9 2096 onSelect: function() {
22f87669 2097 network = libs.bitcoin.networks.auroracoin;
85f762c9 2098 setHdCoin(85);
2099 },
2100 },
cfc0c4d7 2101 {
2102 name: "AXE - Axe",
cfc0c4d7 2103 onSelect: function() {
22f87669 2104 network = libs.bitcoin.networks.axe;
7d9b5f68 2105 setHdCoin(4242);
cfc0c4d7 2106 },
96ee8ab0
IC		 2107 },
2108 {
45588661
KP		 2109 name: "ANON - ANON",
2110 onSelect: function() {
22f87669 2111 network = libs.bitcoin.networks.anon;
45588661
KP		 2112 setHdCoin(220);
2113 },
cfc0c4d7 2114 },
3e7b1ac9
JLE		 2115 {
2116 name: "BOLI - Bolivarcoin",
2117 onSelect: function() {
22f87669 2118 network = libs.bitcoin.networks.bolivarcoin;
3e7b1ac9
JLE		 2119 setHdCoin(278);
2120 },
2121 },
85f762c9 2122 {
2123 name: "BCA - Bitcoin Atom",
85f762c9 2124 onSelect: function() {
22f87669 2125 network = libs.bitcoin.networks.atom;
85f762c9 2126 setHdCoin(185);
2127 },
2128 },
52d698e4 2129 {
2eab7c32 2130 name: "BCH - Bitcoin Cash",
52d698e4 2131 onSelect: function() {
e0f91e20 2132 DOM.bitcoinCashAddressTypeContainer.removeClass("hidden");
2eab7c32 2133 setHdCoin(145);
52d698e4 2134 },
2135 },
daab55dc 2136 {
2eab7c32 2137 name: "BEET - Beetlecoin",
daab55dc 2138 onSelect: function() {
22f87669 2139 network = libs.bitcoin.networks.beetlecoin;
2eab7c32 2140 setHdCoin(800);
daab55dc
IC		 2141 },
2142 },
85f762c9 2143 {
2144 name: "BELA - Belacoin",
85f762c9 2145 onSelect: function() {
22f87669 2146 network = libs.bitcoin.networks.belacoin;
85f762c9 2147 setHdCoin(73);
2148 },
2149 },
892ce76f
IC		 2150 {
2151 name: "BLK - BlackCoin",
892ce76f 2152 onSelect: function() {
22f87669 2153 network = libs.bitcoin.networks.blackcoin;
892ce76f
IC		 2154 setHdCoin(10);
2155 },
2156 },
6f435817
U		 2157 {
2158 name: "BND - Blocknode",
2159 onSelect: function() {
22f87669 2160 network = libs.bitcoin.networks.blocknode;
6f435817
U		 2161 setHdCoin(2941);
2162 },
d0889ab9 2163 },
96ee8ab0 2164 {
6f435817
U		 2165 name: "tBND - Blocknode Testnet",
2166 onSelect: function() {
22f87669 2167 network = libs.bitcoin.networks.blocknode_testnet;
6f435817
U		 2168 setHdCoin(1);
2169 },
2170 },
85f762c9 2171 {
2172 name: "BRIT - Britcoin",
85f762c9 2173 onSelect: function() {
22f87669 2174 network = libs.bitcoin.networks.britcoin;
85f762c9 2175 setHdCoin(70);
2176 },
2177 },
2178 {
2179 name: "BSD - Bitsend",
85f762c9 2180 onSelect: function() {
22f87669 2181 network = libs.bitcoin.networks.bitsend;
85f762c9 2182 setHdCoin(91);
2183 },
f22f7677 2184 },
96ee8ab0 2185 {
f22f7677
PC		 2186 name: "BST - BlockStamp",
2187 onSelect: function() {
22f87669 2188 network = libs.bitcoin.networks.blockstamp;
f22f7677
PC		 2189 setHdCoin(254);
2190 },
85f762c9 2191 },
2192 {
2193 name: "BTA - Bata",
85f762c9 2194 onSelect: function() {
22f87669 2195 network = libs.bitcoin.networks.bata;
85f762c9 2196 setHdCoin(89);
2197 },
2198 },
7f15cb6e 2199 {
534481b6 2200 name: "BTC - Bitcoin",
7a995731 2201 onSelect: function() {
22f87669 2202 network = libs.bitcoin.networks.bitcoin;
6c08f364 2203 setHdCoin(0);
7a995731
IC		 2204 },
2205 },
f1224201
IC		 2206 {
2207 name: "BTC - Bitcoin RegTest",
2208 onSelect: function() {
22f87669 2209 network = libs.bitcoin.networks.regtest;
f1224201
IC		 2210 // Using hd coin value 1 based on bip44_coin_type
2211 // https://github.com/chaintope/bitcoinrb/blob/f1014406f6b8f9b4edcecedc18df70c80df06f11/lib/bitcoin/chainparams/regtest.yml
2212 setHdCoin(1);
2213 },
2214 },
7f15cb6e 2215 {
534481b6 2216 name: "BTC - Bitcoin Testnet",
7a995731 2217 onSelect: function() {
22f87669 2218 network = libs.bitcoin.networks.testnet;
6c08f364 2219 setHdCoin(1);
7a995731 2220 },
8b2a093c 2221 },
96ee8ab0 2222 {
8b2a093c
PC		 2223 name: "BITG - Bitcoin Green",
2224 onSelect: function() {
22f87669 2225 network = libs.bitcoin.networks.bitcoingreen;
8b2a093c
PC		 2226 setHdCoin(222);
2227 },
7a995731 2228 },
1e2cc748 2229 {
2230 name: "BTCP - Bitcoin Private",
1e2cc748 2231 onSelect: function() {
22f87669 2232 network = libs.bitcoin.networks.bitcoinprivate;
1e2cc748 2233 setHdCoin(183);
2234 },
2235 },
995bc587
MRV		 2236 {
2237 name: "BSC - Binance Smart Chain",
2238 onSelect: function() {
2239 network = libs.bitcoin.networks.bitcoin;
2240 setHdCoin(60);
2241 },
2242 },
31264e8b
PT		 2243 {
2244 name: "BSV - BitcoinSV",
2245 onSelect: function() {
22f87669 2246 network = libs.bitcoin.networks.bitcoinsv;
31264e8b
PT		 2247 setHdCoin(236);
2248 },
2249 },
1e2cc748 2250 {
2251 name: "BTCZ - Bitcoinz",
1e2cc748 2252 onSelect: function() {
22f87669 2253 network = libs.bitcoin.networks.bitcoinz;
1e2cc748 2254 setHdCoin(177);
2255 },
2256 },
5ed5f661
D		 2257 {
2258 name: "BTDX - BitCloud",
2259 onSelect: function() {
22f87669 2260 network = libs.bitcoin.networks.bitcloud;
5ed5f661
D		 2261 setHdCoin(218);
2262 },
2263 },
39608073
RS		 2264 {
2265 name: "BTG - Bitcoin Gold",
39608073 2266 onSelect: function() {
22f87669 2267 network = libs.bitcoin.networks.bgold;
88ae1301 2268 setHdCoin(156);
39608073
RS		 2269 },
2270 },
85f762c9 2271 {
2272 name: "BTX - Bitcore",
85f762c9 2273 onSelect: function() {
22f87669 2274 network = libs.bitcoin.networks.bitcore;
85f762c9 2275 setHdCoin(160);
2276 },
2277 },
2278 {
2279 name: "CCN - Cannacoin",
85f762c9 2280 onSelect: function() {
22f87669 2281 network = libs.bitcoin.networks.cannacoin;
85f762c9 2282 setHdCoin(19);
2283 },
2284 },
04ec88af
VD		 2285 {
2286 name: "CESC - Cryptoescudo",
2287 onSelect: function() {
22f87669 2288 network = libs.bitcoin.networks.cannacoin;
04ec88af
VD		 2289 setHdCoin(111);
2290 },
2291 },
85f762c9 2292 {
2293 name: "CDN - Canadaecoin",
85f762c9 2294 onSelect: function() {
22f87669 2295 network = libs.bitcoin.networks.canadaecoin;
85f762c9 2296 setHdCoin(34);
2297 },
2298 },
7f15cb6e 2299 {
534481b6 2300 name: "CLAM - Clams",
7a995731 2301 onSelect: function() {
22f87669 2302 network = libs.bitcoin.networks.clam;
6c08f364 2303 setHdCoin(23);
7a995731
IC		 2304 },
2305 },
bb381a72 2306 {
2307 name: "CLO - Callisto",
2308 segwitAvailable: false,
2309 onSelect: function() {
22f87669 2310 network = libs.bitcoin.networks.bitcoin;
bb381a72 2311 setHdCoin(820);
2312 },
2313 },
85f762c9 2314 {
2315 name: "CLUB - Clubcoin",
85f762c9 2316 onSelect: function() {
22f87669 2317 network = libs.bitcoin.networks.clubcoin;
85f762c9 2318 setHdCoin(79);
2319 },
2320 },
2321 {
2322 name: "CMP - Compcoin",
85f762c9 2323 onSelect: function() {
22f87669 2324 network = libs.bitcoin.networks.compcoin;
85f762c9 2325 setHdCoin(71);
2326 },
2327 },
519e9dc7
MKA		 2328 {
2329 name: "CPU - CPUchain",
2330 onSelect: function() {
22f87669 2331 network = libs.bitcoin.networks.cpuchain;
519e9dc7
MKA		 2332 setHdCoin(363);
2333 },
2334 },
85f762c9 2335 {
2336 name: "CRAVE - Crave",
85f762c9 2337 onSelect: function() {
22f87669 2338 network = libs.bitcoin.networks.crave;
85f762c9 2339 setHdCoin(186);
2340 },
2341 },
115eb450 2342 {
2343 name: "CRP - CranePay",
2344 onSelect: function() {
2345 network = libs.bitcoin.networks.cranepay;
2346 setHdCoin(2304);
2347 },
2348 },
2349
bf13c95f
PC		 2350 {
2351 name: "CRW - Crown (Legacy)",
2352 onSelect: function() {
22f87669 2353 network = libs.bitcoin.networks.crown;
bf13c95f
PC		 2354 setHdCoin(72);
2355 },
2356 },
0921f370 2357 {
2358 name: "CRW - Crown",
2359 onSelect: function() {
22f87669 2360 network = libs.bitcoin.networks.crown;
6c08f364 2361 setHdCoin(72);
0921f370 2362 },
2363 },
45e40c28
C		 2364 {
2365 name: "CSC - CasinoCoin",
2366 onSelect: function() {
22f87669 2367 network = libs.bitcoin.networks.bitcoin;
45e40c28
C		 2368 setHdCoin(359);
2369 },
2370 },
7f15cb6e 2371 {
534481b6 2372 name: "DASH - Dash",
e3a9508c 2373 onSelect: function() {
22f87669 2374 network = libs.bitcoin.networks.dash;
6c08f364 2375 setHdCoin(5);
e3a9508c
IC		 2376 },
2377 },
c0386f3b 2378 {
534481b6 2379 name: "DASH - Dash Testnet",
c0386f3b 2380 onSelect: function() {
22f87669 2381 network = libs.bitcoin.networks.dashtn;
6c08f364 2382 setHdCoin(1);
c0386f3b
KR		 2383 },
2384 },
85f762c9 2385 {
2386 name: "DFC - Defcoin",
85f762c9 2387 onSelect: function() {
22f87669 2388 network = libs.bitcoin.networks.defcoin;
85f762c9 2389 setHdCoin(1337);
2390 },
2391 },
2392 {
2393 name: "DGB - Digibyte",
85f762c9 2394 onSelect: function() {
22f87669 2395 network = libs.bitcoin.networks.digibyte;
85f762c9 2396 setHdCoin(20);
2397 },
2398 },
2399 {
2400 name: "DGC - Digitalcoin",
85f762c9 2401 onSelect: function() {
22f87669 2402 network = libs.bitcoin.networks.digitalcoin;
85f762c9 2403 setHdCoin(18);
2404 },
2405 },
2406 {
2407 name: "DMD - Diamond",
85f762c9 2408 onSelect: function() {
22f87669 2409 network = libs.bitcoin.networks.diamond;
85f762c9 2410 setHdCoin(152);
2411 },
2412 },
40209fd8 2413 {
2414 name: "DNR - Denarius",
40209fd8 2415 onSelect: function() {
22f87669 2416 network = libs.bitcoin.networks.denarius;
50289881 2417 setHdCoin(116);
40209fd8 2418 },
2419 },
e3a9508c 2420 {
534481b6 2421 name: "DOGE - Dogecoin",
2422 onSelect: function() {
22f87669 2423 network = libs.bitcoin.networks.dogecoin;
6c08f364 2424 setHdCoin(3);
534481b6 2425 },
2426 },
b85da074
PD		 2427 {
2428 name: "DOGEt - Dogecoin Testnet",
2429 onSelect: function() {
22f87669 2430 network = libs.bitcoin.networks.dogecointestnet;
b85da074
PD		 2431 setHdCoin(1);
2432 },
2433 },
6cbd3bc8
HL		 2434 {
2435 name: "DXN - DEXON",
2436 onSelect: function() {
22f87669 2437 network = libs.bitcoin.networks.bitcoin;
6cbd3bc8
HL		 2438 setHdCoin(237);
2439 },
2440 },
85f762c9 2441 {
2442 name: "ECN - Ecoin",
85f762c9 2443 onSelect: function() {
22f87669 2444 network = libs.bitcoin.networks.ecoin;
85f762c9 2445 setHdCoin(115);
2446 },
2447 },
2448 {
2449 name: "EDRC - Edrcoin",
85f762c9 2450 onSelect: function() {
22f87669 2451 network = libs.bitcoin.networks.edrcoin;
85f762c9 2452 setHdCoin(56);
2453 },
2454 },
2455 {
2456 name: "EFL - Egulden",
85f762c9 2457 onSelect: function() {
22f87669 2458 network = libs.bitcoin.networks.egulden;
85f762c9 2459 setHdCoin(78);
2460 },
2885ddd5 2461 },
36523e0d
NJ		 2462 {
2463 name: "ELA - Elastos",
2464 onSelect: function () {
22f87669 2465 network = libs.bitcoin.networks.elastos;
36523e0d
NJ		 2466 setHdCoin(2305);
2467 },
2468 },
2885ddd5 2469 {
2470 name: "ELLA - Ellaism",
2471 segwitAvailable: false,
2472 onSelect: function() {
22f87669 2473 network = libs.bitcoin.networks.bitcoin;
2885ddd5 2474 setHdCoin(163);
2475 },
85f762c9 2476 },
2477 {
2478 name: "EMC2 - Einsteinium",
85f762c9 2479 onSelect: function() {
22f87669 2480 network = libs.bitcoin.networks.einsteinium;
85f762c9 2481 setHdCoin(41);
2482 },
2483 },
2484 {
2485 name: "ERC - Europecoin",
85f762c9 2486 onSelect: function() {
22f87669 2487 network = libs.bitcoin.networks.europecoin;
85f762c9 2488 setHdCoin(151);
2489 },
2490 },
3451d1a8
JU		 2491 {
2492 name: "EOS - EOSIO",
2493 onSelect: function() {
22f87669 2494 network = libs.bitcoin.networks.bitcoin;
3451d1a8
JU		 2495 setHdCoin(194);
2496 },
2497 },
8131a071
EC		 2498 {
2499 name: "ERE - EtherCore",
2500 segwitAvailable: false,
2501 onSelect: function() {
2502 network = libs.bitcoin.networks.bitcoin;
2503 setHdCoin(466);
2504 },
2505 },
16afe3ec 2506 {
2507 name: "ESN - Ethersocial Network",
2508 segwitAvailable: false,
2509 onSelect: function() {
22f87669 2510 network = libs.bitcoin.networks.bitcoin;
16afe3ec 2511 setHdCoin(31102);
2512 },
2513 },
bb381a72 2514 {
2515 name: "ETC - Ethereum Classic",
2516 segwitAvailable: false,
2517 onSelect: function() {
22f87669 2518 network = libs.bitcoin.networks.bitcoin;
bb381a72 2519 setHdCoin(61);
2520 },
2521 },
534481b6 2522 {
2523 name: "ETH - Ethereum",
e3a9508c 2524 onSelect: function() {
22f87669 2525 network = libs.bitcoin.networks.bitcoin;
6c08f364 2526 setHdCoin(60);
e3a9508c 2527 },
dd99c5fd
GM		 2528 },
2529 {
2530 name: "EWT - EnergyWeb",
2531 onSelect: function() {
22f87669 2532 network = libs.bitcoin.networks.bitcoin;
dd99c5fd
GM		 2533 setHdCoin(246);
2534 },
2535 },
85f762c9 2536 {
2537 name: "EXCL - Exclusivecoin",
85f762c9 2538 onSelect: function() {
22f87669 2539 network = libs.bitcoin.networks.exclusivecoin;
85f762c9 2540 setHdCoin(190);
2541 },
2542 },
a44c45e3 2543 {
2544 name: "EXCC - ExchangeCoin",
2545 onSelect: function() {
22f87669 2546 network = libs.bitcoin.networks.exchangecoin;
a44c45e3 2547 setHdCoin(0);
2548 },
2549 },
bb381a72 2550 {
2551 name: "EXP - Expanse",
2552 segwitAvailable: false,
2553 onSelect: function() {
22f87669 2554 network = libs.bitcoin.networks.bitcoin;
bb381a72 2555 setHdCoin(40);
2556 },
2557 },
d1d8699f
SA		 2558 {
2559 name: "FIO - Foundation for Interwallet Operability",
2560 onSelect: function() {
2561 network = libs.bitcoin.networks.bitcoin;
2562 setHdCoin(235);
2563 },
2564 },
7d4e4cbe 2565 {
2566 name: "FIX - FIX",
2567 onSelect: function() {
22f87669 2568 network = libs.bitcoin.networks.fix;
7d4e4cbe 2569 setHdCoin(336);
2570 },
2571 },
2572 {
2573 name: "FIX - FIX Testnet",
2574 onSelect: function() {
22f87669 2575 network = libs.bitcoin.networks.fixtestnet;
7d4e4cbe 2576 setHdCoin(1);
2577 },
2578 },
6e679905 2579 {
2580 name: "FJC - Fujicoin",
6e679905 2581 onSelect: function() {
22f87669 2582 network = libs.bitcoin.networks.fujicoin;
6e679905 2583 setHdCoin(75);
2584 },
2585 },
85f762c9 2586 {
2587 name: "FLASH - Flashcoin",
85f762c9 2588 onSelect: function() {
22f87669 2589 network = libs.bitcoin.networks.flashcoin;
85f762c9 2590 setHdCoin(120);
2591 },
2592 },
2593 {
2594 name: "FRST - Firstcoin",
85f762c9 2595 onSelect: function() {
22f87669 2596 network = libs.bitcoin.networks.firstcoin;
85f762c9 2597 setHdCoin(167);
2598 },
2599 },
2600 {
2601 name: "FTC - Feathercoin",
85f762c9 2602 onSelect: function() {
22f87669 2603 network = libs.bitcoin.networks.feathercoin;
85f762c9 2604 setHdCoin(8);
2605 },
2606 },
f88fab20 2607 {
534481b6 2608 name: "GAME - GameCredits",
f88fab20 2609 onSelect: function() {
22f87669 2610 network = libs.bitcoin.networks.game;
6c08f364 2611 setHdCoin(101);
f88fab20 2612 },
2613 },
85f762c9 2614 {
2615 name: "GBX - Gobyte",
85f762c9 2616 onSelect: function() {
22f87669 2617 network = libs.bitcoin.networks.gobyte;
85f762c9 2618 setHdCoin(176);
2619 },
2620 },
2621 {
2622 name: "GCR - GCRCoin",
85f762c9 2623 onSelect: function() {
22f87669 2624 network = libs.bitcoin.networks.gcr;
85f762c9 2625 setHdCoin(79);
2626 },
2627 },
2628 {
2629 name: "GRC - Gridcoin",
85f762c9 2630 onSelect: function() {
22f87669 2631 network = libs.bitcoin.networks.gridcoin;
85f762c9 2632 setHdCoin(84);
2633 },
76120cb0
H		 2634 },
2635 {
2636 name: "GRS - Groestlcoin",
2637 onSelect: function() {
22f87669 2638 network = libs.bitcoin.networks.groestlcoin;
76120cb0
H		 2639 setHdCoin(17);
2640 },
2641 },
2642 {
2643 name: "GRS - Groestlcoin Testnet",
2644 onSelect: function() {
22f87669 2645 network = libs.bitcoin.networks.groestlcointestnet;
76120cb0
H		 2646 setHdCoin(1);
2647 },
85f762c9 2648 },
0e1fd953
JK		 2649 {
2650 name: "HNS - Handshake",
2651 onSelect: function() {
2652 setHdCoin(5353);
2653 },
2654 },
85f762c9 2655 {
2656 name: "HNC - Helleniccoin",
85f762c9 2657 onSelect: function() {
22f87669 2658 network = libs.bitcoin.networks.helleniccoin;
85f762c9 2659 setHdCoin(168);
2660 },
60727c51 2661 },
96ee8ab0 2662 {
318ec4dc 2663 name: "HUSH - Hush (Legacy)",
60727c51 2664 onSelect: function() {
22f87669 2665 network = libs.bitcoin.networks.hush;
60727c51
PC		 2666 setHdCoin(197);
2667 },
85f762c9 2668 },
96ee8ab0 2669 {
318ec4dc
PC		 2670 name: "HUSH - Hush3",
2671 onSelect: function() {
22f87669 2672 network = libs.bitcoin.networks.hush3;
318ec4dc
PC		 2673 setHdCoin(197);
2674 },
2675 },
85f762c9 2676 {
2677 name: "INSN - Insane",
85f762c9 2678 onSelect: function() {
22f87669 2679 network = libs.bitcoin.networks.insane;
85f762c9 2680 setHdCoin(68);
2681 },
2682 },
2683 {
2684 name: "IOP - Iop",
85f762c9 2685 onSelect: function() {
22f87669 2686 network = libs.bitcoin.networks.iop;
85f762c9 2687 setHdCoin(66);
2688 },
2689 },
2690 {
2691 name: "IXC - Ixcoin",
85f762c9 2692 onSelect: function() {
22f87669 2693 network = libs.bitcoin.networks.ixcoin;
85f762c9 2694 setHdCoin(86);
2695 },
2696 },
a3baa26e 2697 {
534481b6 2698 name: "JBS - Jumbucks",
a3baa26e 2699 onSelect: function() {
22f87669 2700 network = libs.bitcoin.networks.jumbucks;
6c08f364 2701 setHdCoin(26);
a3baa26e
IC		 2702 },
2703 },
aab3645f 2704 {
2705 name: "KMD - Komodo",
2706 bip49available: false,
2707 onSelect: function() {
22f87669 2708 network = libs.bitcoin.networks.komodo;
aab3645f 2709 setHdCoin(141);
2710 },
2711 },
0a5d28a7 2712 {
2713 name: "KOBO - Kobocoin",
2714 bip49available: false,
2715 onSelect: function() {
22f87669 2716 network = libs.bitcoin.networks.kobocoin;
0a5d28a7 2717 setHdCoin(196);
2718 },
2719 },
85f762c9 2720 {
2721 name: "LBC - Library Credits",
85f762c9 2722 onSelect: function() {
22f87669 2723 network = libs.bitcoin.networks.lbry;
85f762c9 2724 setHdCoin(140);
2725 },
2726 },
2727 {
2728 name: "LCC - Litecoincash",
85f762c9 2729 onSelect: function() {
22f87669 2730 network = libs.bitcoin.networks.litecoincash;
85f762c9 2731 setHdCoin(192);
2732 },
2733 },
2734 {
2735 name: "LDCN - Landcoin",
85f762c9 2736 onSelect: function() {
22f87669 2737 network = libs.bitcoin.networks.landcoin;
85f762c9 2738 setHdCoin(63);
2739 },
2740 },
2741 {
2742 name: "LINX - Linx",
85f762c9 2743 onSelect: function() {
22f87669 2744 network = libs.bitcoin.networks.linx;
85f762c9 2745 setHdCoin(114);
2746 },
2747 },
8ba31a89
JLEP		 2748 {
2749 name: "LKR - Lkrcoin",
2750 segwitAvailable: false,
2751 onSelect: function() {
22f87669 2752 network = libs.bitcoin.networks.lkrcoin;
8ba31a89
JLEP		 2753 setHdCoin(557);
2754 },
2755 },
a3baa26e 2756 {
534481b6 2757 name: "LTC - Litecoin",
a3baa26e 2758 onSelect: function() {
22f87669 2759 network = libs.bitcoin.networks.litecoin;
6c08f364 2760 setHdCoin(2);
3abab9b0 2761 DOM.litecoinLtubContainer.removeClass("hidden");
a3baa26e
IC		 2762 },
2763 },
b85da074
PD		 2764 {
2765 name: "LTCt - Litecoin Testnet",
2766 onSelect: function() {
22f87669 2767 network = libs.bitcoin.networks.litecointestnet;
b85da074
PD		 2768 setHdCoin(1);
2769 DOM.litecoinLtubContainer.removeClass("hidden");
2770 },
2771 },
d4fcdda9
PC		 2772 {
2773 name: "LTZ - LitecoinZ",
2774 onSelect: function() {
22f87669 2775 network = libs.bitcoin.networks.litecoinz;
d4fcdda9
PC		 2776 setHdCoin(221);
2777 },
2778 },
85f762c9 2779 {
2780 name: "LYNX - Lynx",
85f762c9 2781 onSelect: function() {
22f87669 2782 network = libs.bitcoin.networks.lynx;
85f762c9 2783 setHdCoin(191);
2784 },
2785 },
56ad9601
JS		 2786 {
2787 name: "MAZA - Maza",
56ad9601 2788 onSelect: function() {
22f87669 2789 network = libs.bitcoin.networks.maza;
56ad9601
JS		 2790 setHdCoin(13);
2791 },
2792 },
5ed5f661
D		 2793 {
2794 name: "MEC - Megacoin",
2795 onSelect: function() {
22f87669 2796 network = libs.bitcoin.networks.megacoin;
5ed5f661
D		 2797 setHdCoin(217);
2798 },
2799 },
bb381a72 2800 {
2801 name: "MIX - MIX",
2802 segwitAvailable: false,
2803 onSelect: function() {
22f87669 2804 network = libs.bitcoin.networks.bitcoin;
bb381a72 2805 setHdCoin(76);
2806 },
2807 },
85f762c9 2808 {
2809 name: "MNX - Minexcoin",
85f762c9 2810 onSelect: function() {
22f87669 2811 network = libs.bitcoin.networks.minexcoin;
85f762c9 2812 setHdCoin(182);
2813 },
2814 },
f487fea9
IC		 2815 {
2816 name: "MONA - Monacoin",
f487fea9 2817 onSelect: function() {
22f87669 2818 network = libs.bitcoin.networks.monacoin,
f487fea9
IC		 2819 setHdCoin(22);
2820 },
2821 },
31264e8b
PT		 2822 {
2823 name: "MONK - Monkey Project",
2824 onSelect: function() {
22f87669 2825 network = libs.bitcoin.networks.monkeyproject,
31264e8b
PT		 2826 setHdCoin(214);
2827 },
2828 },
46a5338e
LL		 2829 {
2830 name: "MOAC - MOAC",
2831 segwitAvailable: false,
2832 onSelect: function() {
2833 network = libs.bitcoin.networks.bitcoin;
2834 setHdCoin(314);
2835 },
2836 },
bb381a72 2837 {
2838 name: "MUSIC - Musicoin",
2839 segwitAvailable: false,
2840 onSelect: function() {
22f87669 2841 network = libs.bitcoin.networks.bitcoin;
bb381a72 2842 setHdCoin(184);
2843 },
2844 },
85f762c9 2845 {
2846 name: "NAV - Navcoin",
85f762c9 2847 onSelect: function() {
22f87669 2848 network = libs.bitcoin.networks.navcoin;
85f762c9 2849 setHdCoin(130);
2850 },
2851 },
7a113003 2852 {
2853 name: "NAS - Nebulas",
2854 onSelect: function() {
22f87669 2855 network = libs.bitcoin.networks.bitcoin;
7a113003 2856 setHdCoin(2718);
2857 },
2858 },
db37d639
IC		 2859 {
2860 name: "NEBL - Neblio",
db37d639 2861 onSelect: function() {
22f87669 2862 network = libs.bitcoin.networks.neblio;
db37d639
IC		 2863 setHdCoin(146);
2864 },
2865 },
85f762c9 2866 {
2867 name: "NEOS - Neoscoin",
85f762c9 2868 onSelect: function() {
22f87669 2869 network = libs.bitcoin.networks.neoscoin;
85f762c9 2870 setHdCoin(25);
2871 },
2872 },
10980ed6 2873 {
2874 name: "NIX - NIX Platform",
2875 onSelect: function() {
22f87669 2876 network = libs.bitcoin.networks.nix;
10980ed6 2877 setHdCoin(400);
2878 },
2879 },
85f762c9 2880 {
2881 name: "NLG - Gulden",
85f762c9 2882 onSelect: function() {
22f87669 2883 network = libs.bitcoin.networks.gulden;
85f762c9 2884 setHdCoin(87);
2885 },
2886 },
a3baa26e 2887 {
534481b6 2888 name: "NMC - Namecoin",
a3baa26e 2889 onSelect: function() {
22f87669 2890 network = libs.bitcoin.networks.namecoin;
6c08f364 2891 setHdCoin(7);
a3baa26e
IC		 2892 },
2893 },
1e2cc748 2894 {
2895 name: "NRG - Energi",
1e2cc748 2896 onSelect: function() {
22f87669 2897 network = libs.bitcoin.networks.energi;
1e2cc748 2898 setHdCoin(204);
2899 },
2900 },
85f762c9 2901 {
2902 name: "NRO - Neurocoin",
85f762c9 2903 onSelect: function() {
22f87669 2904 network = libs.bitcoin.networks.neurocoin;
85f762c9 2905 setHdCoin(110);
2906 },
2907 },
2908 {
2909 name: "NSR - Nushares",
85f762c9 2910 onSelect: function() {
22f87669 2911 network = libs.bitcoin.networks.nushares;
85f762c9 2912 setHdCoin(11);
2913 },
2914 },
2915 {
2916 name: "NYC - Newyorkc",
85f762c9 2917 onSelect: function() {
22f87669 2918 network = libs.bitcoin.networks.newyorkc;
85f762c9 2919 setHdCoin(179);
2920 },
2921 },
2922 {
2923 name: "NVC - Novacoin",
85f762c9 2924 onSelect: function() {
22f87669 2925 network = libs.bitcoin.networks.novacoin;
85f762c9 2926 setHdCoin(50);
2927 },
2928 },
2929 {
2930 name: "OK - Okcash",
85f762c9 2931 onSelect: function() {
22f87669 2932 network = libs.bitcoin.networks.okcash;
85f762c9 2933 setHdCoin(69);
2934 },
2935 },
2936 {
2937 name: "OMNI - Omnicore",
85f762c9 2938 onSelect: function() {
22f87669 2939 network = libs.bitcoin.networks.omnicore;
85f762c9 2940 setHdCoin(200);
2941 },
2942 },
af14981d
A		 2943 {
2944 name: "ONION - DeepOnion",
2945 onSelect: function() {
22f87669 2946 network = libs.bitcoin.networks.deeponion;
af14981d
A		 2947 setHdCoin(305);
2948 },
2949 },
66419cf3 2950 {
2951 name: "ONX - Onixcoin",
66419cf3 2952 onSelect: function() {
22f87669 2953 network = libs.bitcoin.networks.onixcoin;
d00c7199 2954 setHdCoin(174);
66419cf3 2955 },
38d1b296 2956 },
96ee8ab0 2957 {
38d1b296
PC		 2958 name: "PHR - Phore",
2959 onSelect: function() {
22f87669 2960 network = libs.bitcoin.networks.phore;
38d1b296
PC		 2961 setHdCoin(444);
2962 },
66419cf3 2963 },
85f762c9 2964 {
2965 name: "PINK - Pinkcoin",
85f762c9 2966 onSelect: function() {
22f87669 2967 network = libs.bitcoin.networks.pinkcoin;
85f762c9 2968 setHdCoin(117);
2969 },
2970 },
bb381a72 2971 {
2972 name: "PIRL - Pirl",
2973 segwitAvailable: false,
2974 onSelect: function() {
22f87669 2975 network = libs.bitcoin.networks.bitcoin;
bb381a72 2976 setHdCoin(164);
2977 },
2978 },
c0df0189 2979 {
2980 name: "PIVX - PIVX",
c0df0189 2981 onSelect: function() {
22f87669 2982 network = libs.bitcoin.networks.pivx;
c0df0189 2983 setHdCoin(119);
2984 },
2985 },
2986 {
2987 name: "PIVX - PIVX Testnet",
c0df0189 2988 onSelect: function() {
22f87669 2989 network = libs.bitcoin.networks.pivxtestnet;
c0df0189 2990 setHdCoin(1);
2991 },
2992 },
bb381a72 2993 {
2994 name: "POA - Poa",
2995 segwitAvailable: false,
2996 onSelect: function() {
22f87669 2997 network = libs.bitcoin.networks.bitcoin;
bb381a72 2998 setHdCoin(178);
2999 },
3000 },
85f762c9 3001 {
3002 name: "POSW - POSWcoin",
85f762c9 3003 onSelect: function() {
22f87669 3004 network = libs.bitcoin.networks.poswcoin;
85f762c9 3005 setHdCoin(47);
3006 },
3007 },
3008 {
3009 name: "POT - Potcoin",
85f762c9 3010 onSelect: function() {
22f87669 3011 network = libs.bitcoin.networks.potcoin;
85f762c9 3012 setHdCoin(81);
3013 },
3014 },
5c434a8a 3015 {
534481b6 3016 name: "PPC - Peercoin",
5c434a8a 3017 onSelect: function() {
22f87669 3018 network = libs.bitcoin.networks.peercoin;
6c08f364 3019 setHdCoin(6);
5c434a8a 3020 },
d2ba3871 3021 },
96ee8ab0 3022 {
d2ba3871
PC		 3023 name: "PRJ - ProjectCoin",
3024 onSelect: function() {
22f87669 3025 network = libs.bitcoin.networks.projectcoin;
d2ba3871
PC		 3026 setHdCoin(533);
3027 },
5c434a8a 3028 },
85f762c9 3029 {
3030 name: "PSB - Pesobit",
85f762c9 3031 onSelect: function() {
22f87669 3032 network = libs.bitcoin.networks.pesobit;
85f762c9 3033 setHdCoin(62);
3034 },
3035 },
3036 {
3037 name: "PUT - Putincoin",
85f762c9 3038 onSelect: function() {
22f87669 3039 network = libs.bitcoin.networks.putincoin;
85f762c9 3040 setHdCoin(122);
3041 },
3042 },
31264e8b
PT		 3043 {
3044 name: "RPD - Rapids",
3045 onSelect: function() {
22f87669 3046 network = libs.bitcoin.networks.rapids;
31264e8b
PT		 3047 setHdCoin(320);
3048 },
3049 },
1fe8f519 3050 {
3051 name: "RVN - Ravencoin",
3052 onSelect: function() {
22f87669 3053 network = libs.bitcoin.networks.ravencoin;
1fe8f519 3054 setHdCoin(175);
3055 },
3056 },
e9491c7e 3057 {
b64fb353 3058 name: "R-BTC - RSK",
e9491c7e 3059 onSelect: function() {
b64fb353 3060 network = libs.bitcoin.networks.rsk;
e9491c7e
I		 3061 setHdCoin(137);
3062 },
3063 },
3064 {
b64fb353 3065 name: "tR-BTC - RSK Testnet",
e9491c7e 3066 onSelect: function() {
b64fb353 3067 network = libs.bitcoin.networks.rsktestnet;
e9491c7e
I		 3068 setHdCoin(37310);
3069 },
3070 },
85f762c9 3071 {
3072 name: "RBY - Rubycoin",
85f762c9 3073 onSelect: function() {
22f87669 3074 network = libs.bitcoin.networks.rubycoin;
85f762c9 3075 setHdCoin(16);
3076 },
3077 },
3078 {
3079 name: "RDD - Reddcoin",
85f762c9 3080 onSelect: function() {
22f87669 3081 network = libs.bitcoin.networks.reddcoin;
85f762c9 3082 setHdCoin(4);
3083 },
3084 },
3085 {
3086 name: "RVR - RevolutionVR",
85f762c9 3087 onSelect: function() {
22f87669 3088 network = libs.bitcoin.networks.revolutionvr;
85f762c9 3089 setHdCoin(129);
3090 },
3091 },
7878bb32 3092 {
d645b982
E		 3093 name: "SAFE - Safecoin",
3094 onSelect: function() {
22f87669 3095 network = libs.bitcoin.networks.safecoin;
d645b982
E		 3096 setHdCoin(19165);
3097 },
3098 },
fba7e98a 3099 {
3100 name: "SCRIBE - Scribe",
3101 onSelect: function() {
3102 network = libs.bitcoin.networks.scribe;
3103 setHdCoin(545);
3104 },
3105 },
96ee8ab0 3106 {
7878bb32
S		 3107 name: "SLS - Salus",
3108 onSelect: function() {
22f87669 3109 network = libs.bitcoin.networks.salus;
7878bb32
S		 3110 setHdCoin(63);
3111 },
3112 },
64a7d2aa 3113 {
534481b6 3114 name: "SDC - ShadowCash",
82f91834 3115 onSelect: function() {
22f87669 3116 network = libs.bitcoin.networks.shadow;
6c08f364 3117 setHdCoin(35);
82f91834
DG		 3118 },
3119 },
07ac4350 3120 {
534481b6 3121 name: "SDC - ShadowCash Testnet",
07ac4350 3122 onSelect: function() {
22f87669 3123 network = libs.bitcoin.networks.shadowtn;
6c08f364 3124 setHdCoin(1);
07ac4350 3125 },
3126 },
7a5a87a0 3127 {
534481b6 3128 name: "SLM - Slimcoin",
7a5a87a0 3129 onSelect: function() {
22f87669 3130 network = libs.bitcoin.networks.slimcoin;
6c08f364 3131 setHdCoin(63);
7a5a87a0
GH		 3132 },
3133 },
3134 {
534481b6 3135 name: "SLM - Slimcoin Testnet",
7a5a87a0 3136 onSelect: function() {
22f87669 3137 network = libs.bitcoin.networks.slimcointn;
6c08f364 3138 setHdCoin(111);
7a5a87a0
GH		 3139 },
3140 },
d0889ab9 3141 {
3142 name: "SLP - Simple Ledger Protocol",
3143 onSelect: function() {
3144 DOM.bitcoinCashAddressTypeContainer.removeClass("hidden");
3145 setHdCoin(245);
3146 },
3147 },
85f762c9 3148 {
3149 name: "SLR - Solarcoin",
85f762c9 3150 onSelect: function() {
22f87669 3151 network = libs.bitcoin.networks.solarcoin;
85f762c9 3152 setHdCoin(58);
3153 },
3154 },
3155 {
3156 name: "SMLY - Smileycoin",
85f762c9 3157 onSelect: function() {
22f87669 3158 network = libs.bitcoin.networks.smileycoin;
85f762c9 3159 setHdCoin(59);
3160 },
3161 },
ae51db39
B		 3162 {
3163 name: "STASH - Stash",
3164 onSelect: function() {
22f87669 3165 network = libs.bitcoin.networks.stash;
ae51db39
B		 3166 setHdCoin(0xC0C0);
3167 },
3168 },
3169 {
3170 name: "STASH - Stash Testnet",
3171 onSelect: function() {
22f87669 3172 network = libs.bitcoin.networks.stashtn;
ae51db39
B		 3173 setHdCoin(0xCAFE);
3174 },
3175 },
85f762c9 3176 {
3177 name: "STRAT - Stratis",
85f762c9 3178 onSelect: function() {
22f87669 3179 network = libs.bitcoin.networks.stratis;
85f762c9 3180 setHdCoin(105);
3181 },
3182 },
4958ea80
JC		 3183 {
3184 name: "SUGAR - Sugarchain",
3185 onSelect: function() {
3186 network = libs.bitcoin.networks.sugarchain;
3187 setHdCoin(408);
3188 },
3189 },
75944050
JC		 3190 {
3191 name: "TUGAR - Sugarchain Testnet",
3192 onSelect: function() {
3193 network = libs.bitcoin.networks.sugarchaintestnet;
3194 setHdCoin(408);
3195 },
3196 },
46a5338e
LL		 3197 {
3198 name: "SWTC - Jingtum",
3199 onSelect: function() {
3200 network = libs.bitcoin.networks.bitcoin;
3201 setHdCoin(315);
3202 },
3203 },
3b43552c
AD		 3204 {
3205 name: "TSTRAT - Stratis Testnet",
3206 onSelect: function() {
22f87669 3207 network = libs.bitcoin.networks.stratistest;
3b43552c
AD		 3208 setHdCoin(105);
3209 },
3210 },
85f762c9 3211 {
3212 name: "SYS - Syscoin",
85f762c9 3213 onSelect: function() {
22f87669 3214 network = libs.bitcoin.networks.syscoin;
85f762c9 3215 setHdCoin(57);
3216 },
3217 },
3218 {
3219 name: "THC - Hempcoin",
85f762c9 3220 onSelect: function() {
22f87669 3221 network = libs.bitcoin.networks.hempcoin;
85f762c9 3222 setHdCoin(113);
3223 },
3224 },
75138bee
A		 3225 {
3226 name: "THT - Thought",
3227 onSelect: function() {
22f87669 3228 network = libs.bitcoin.networks.thought;
75138bee
A		 3229 setHdCoin(1618);
3230 },
3231 },
85f762c9 3232 {
3233 name: "TOA - Toa",
85f762c9 3234 onSelect: function() {
22f87669 3235 network = libs.bitcoin.networks.toa;
85f762c9 3236 setHdCoin(159);
3237 },
3238 },
82e3938a 3239 {
3240 name: "TWINS - TWINS",
3241 onSelect: function() {
22f87669 3242 network = libs.bitcoin.networks.twins;
82e3938a 3243 setHdCoin(970);
3244 },
3245 },
3246 {
3247 name: "TWINS - TWINS Testnet",
3248 onSelect: function() {
22f87669 3249 network = libs.bitcoin.networks.twinstestnet;
82e3938a 3250 setHdCoin(1);
3251 },
3252 },
85f762c9 3253 {
3254 name: "USC - Ultimatesecurecash",
85f762c9 3255 onSelect: function() {
22f87669 3256 network = libs.bitcoin.networks.ultimatesecurecash;
85f762c9 3257 setHdCoin(112);
3258 },
3259 },
8dd28f2c 3260 {
3261 name: "USNBT - NuBits",
8dd28f2c 3262 onSelect: function() {
22f87669 3263 network = libs.bitcoin.networks.nubits;
8dd28f2c 3264 setHdCoin(12);
3265 },
3266 },
85f762c9 3267 {
3268 name: "UNO - Unobtanium",
85f762c9 3269 onSelect: function() {
22f87669 3270 network = libs.bitcoin.networks.unobtanium;
85f762c9 3271 setHdCoin(92);
3272 },
3273 },
3274 {
3275 name: "VASH - Vpncoin",
85f762c9 3276 onSelect: function() {
22f87669 3277 network = libs.bitcoin.networks.vpncoin;
85f762c9 3278 setHdCoin(33);
3279 },
3280 },
c7a1a000
MR		 3281 {
3282 name: "VET - VeChain",
3283 onSelect: function() {
22f87669 3284 network = libs.bitcoin.networks.bitcoin;
c7a1a000
MR		 3285 setHdCoin(818);
3286 },
3287 },
07ac4350 3288 {
534481b6 3289 name: "VIA - Viacoin",
07ac4350 3290 onSelect: function() {
22f87669 3291 network = libs.bitcoin.networks.viacoin;
6c08f364 3292 setHdCoin(14);
07ac4350 3293 },
3294 },
0edac945 3295 {
534481b6 3296 name: "VIA - Viacoin Testnet",
0edac945 3297 onSelect: function() {
22f87669 3298 network = libs.bitcoin.networks.viacointestnet;
6c08f364 3299 setHdCoin(1);
0edac945
IC		 3300 },
3301 },
85f762c9 3302 {
3303 name: "VIVO - Vivo",
85f762c9 3304 onSelect: function() {
22f87669 3305 network = libs.bitcoin.networks.vivo;
85f762c9 3306 setHdCoin(166);
3307 },
3308 },
3309 {
3310 name: "VTC - Vertcoin",
85f762c9 3311 onSelect: function() {
22f87669 3312 network = libs.bitcoin.networks.vertcoin;
85f762c9 3313 setHdCoin(28);
3314 },
3315 },
67f18e2a
C		 3316 {
3317 name: "WGR - Wagerr",
3318 onSelect: function() {
22f87669 3319 network = libs.bitcoin.networks.wagerr;
67f18e2a
C		 3320 setHdCoin(7825266);
3321 },
3322 },
85f762c9 3323 {
3324 name: "WC - Wincoin",
85f762c9 3325 onSelect: function() {
22f87669 3326 network = libs.bitcoin.networks.wincoin;
85f762c9 3327 setHdCoin(181);
3328 },
2575538b 3329 },
96ee8ab0 3330 {
2575538b
PC		 3331 name: "XAX - Artax",
3332 onSelect: function() {
22f87669 3333 network = libs.bitcoin.networks.artax;
2575538b
PC		 3334 setHdCoin(219);
3335 },
85f762c9 3336 },
3337 {
3338 name: "XBC - Bitcoinplus",
85f762c9 3339 onSelect: function() {
22f87669 3340 network = libs.bitcoin.networks.bitcoinplus;
85f762c9 3341 setHdCoin(65);
3342 },
3343 },
612d6b42
SÖ		 3344 {
3345 name: "XLM - Stellar",
3346 onSelect: function() {
22f87669 3347 network = libs.stellarUtil.dummyNetwork;
612d6b42
SÖ		 3348 setHdCoin(148);
3349 },
3350 },
534481b6 3351 {
7ebdf61c 3352 name: "XMY - Myriadcoin",
534481b6 3353 onSelect: function() {
22f87669 3354 network = libs.bitcoin.networks.myriadcoin;
7ebdf61c 3355 setHdCoin(90);
534481b6 3356 },
adedbf91 3357 },
3358 {
7ebdf61c 3359 name: "XRP - Ripple",
adedbf91 3360 onSelect: function() {
22f87669 3361 network = libs.bitcoin.networks.bitcoin;
7ebdf61c 3362 setHdCoin(144);
adedbf91 3363 },
e1d0cf4f 3364 },
85f762c9 3365 {
3366 name: "XVC - Vcash",
85f762c9 3367 onSelect: function() {
22f87669 3368 network = libs.bitcoin.networks.vcash;
85f762c9 3369 setHdCoin(127);
3370 },
3371 },
3372 {
3373 name: "XVG - Verge",
85f762c9 3374 onSelect: function() {
22f87669 3375 network = libs.bitcoin.networks.verge;
85f762c9 3376 setHdCoin(77);
3377 },
3378 },
bb381a72 3379 {
3380 name: "XUEZ - Xuez",
3381 segwitAvailable: false,
3382 onSelect: function() {
22f87669 3383 network = libs.bitcoin.networks.xuez;
bb381a72 3384 setHdCoin(225);
3385 },
3386 },
85f762c9 3387 {
3388 name: "XWC - Whitecoin",
85f762c9 3389 onSelect: function() {
22f87669 3390 network = libs.bitcoin.networks.whitecoin;
85f762c9 3391 setHdCoin(155);
3392 },
3393 },
3394 {
3395 name: "XZC - Zcoin",
85f762c9 3396 onSelect: function() {
22f87669 3397 network = libs.bitcoin.networks.zcoin;
85f762c9 3398 setHdCoin(136);
3399 },
3400 },
1e2cc748 3401 {
3402 name: "ZCL - Zclassic",
1e2cc748 3403 onSelect: function() {
22f87669 3404 network = libs.bitcoin.networks.zclassic;
1e2cc748 3405 setHdCoin(147);
3406 },
3407 },
0702ecd3 3408 {
3409 name: "ZEC - Zcash",
0702ecd3 3410 onSelect: function() {
22f87669 3411 network = libs.bitcoin.networks.zcash;
0702ecd3 3412 setHdCoin(133);
3413 },
3414 },
1e2cc748 3415 {
9cec5dd2 3416 name: "ZEN - Horizen",
1e2cc748 3417 onSelect: function() {
22f87669 3418 network = libs.bitcoin.networks.zencash;
1e2cc748 3419 setHdCoin(121);
3420 },
3421 },
7f15cb6e 3422 ]
6ee4fb7d 3423
b4fd763c
AG		 3424 var clients = [
3425 {
3426 name: "Bitcoin Core",
3427 onSelect: function() {
3428 DOM.bip32path.val("m/0'/0'");
3429 DOM.hardenedAddresses.prop('checked', true);
3430 },
3431 },
3432 {
3433 name: "blockchain.info",
3434 onSelect: function() {
3435 DOM.bip32path.val("m/44'/0'/0'");
3436 DOM.hardenedAddresses.prop('checked', false);
3437 },
3438 },
3439 {
3440 name: "MultiBit HD",
3441 onSelect: function() {
3442 DOM.bip32path.val("m/0'/0");
3443 DOM.hardenedAddresses.prop('checked', false);
3444 },
bb381a72 3445 },
3446 {
3447 name: "Coinomi, Ledger",
3448 onSelect: function() {
3449 DOM.bip32path.val("m/44'/"+DOM.bip44coin.val()+"'/0'");
3450 DOM.hardenedAddresses.prop('checked', false);
3451 },
b4fd763c
AG		 3452 }
3453 ]
7a995731 3454
a823e526 3455 // RSK - RSK functions - begin
3456 function stripHexPrefix(address) {
3457 if (typeof address !== "string") {
3458 throw new Error("address parameter should be a string.");
3459 }
3460
3461 var hasPrefix = (address.substring(0, 2) === "0x" ||
3462 address.substring(0, 2) === "0X");
3463
3464 return hasPrefix ? address.slice(2) : address;
3465 };
3466
3467 function toChecksumAddressForRsk(address, chainId = null) {
3468 if (typeof address !== "string") {
3469 throw new Error("address parameter should be a string.");
3470 }
3471
3472 if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) {
3473 throw new Error("Given address is not a valid RSK address: " + address);
3474 }
3475
3476 var stripAddress = stripHexPrefix(address).toLowerCase();
3477 var prefix = chainId != null ? chainId.toString() + "0x" : "";
3478 var keccakHash = libs.ethUtil.keccak256(prefix + stripAddress)
3479 .toString("hex")
3480 .replace(/^0x/i, "");
3481 var checksumAddress = "0x";
3482
3483 for (var i = 0; i < stripAddress.length; i++) {
3484 checksumAddress +=
3485 parseInt(keccakHash[i], 16) >= 8 ?
3486 stripAddress[i].toUpperCase() :
3487 stripAddress[i];
3488 }
3489
3490 return checksumAddress;
3491 }
3492
3493 // RSK - RSK functions - end
3494
36523e0d
NJ		 3495 // ELA - Elastos functions - begin
3496 function displayBip44InfoForELA() {
3497 if (!isELA()) {
3498 return;
3499 }
3500
3501 var coin = parseIntNoNaN(DOM.bip44coin.val(), 0);
3502 var account = parseIntNoNaN(DOM.bip44account.val(), 0);
3503
3504 // Calculate the account extended keys
22f87669
IC		 3505 var accountXprv = libs.elastosjs.getAccountExtendedPrivateKey(seed, coin, account);
3506 var accountXpub = libs.elastosjs.getAccountExtendedPublicKey(seed, coin, account);
36523e0d
NJ		 3507
3508 // Display the extended keys
3509 DOM.bip44accountXprv.val(accountXprv);
3510 DOM.bip44accountXpub.val(accountXpub);
3511 }
3512
3513 function displayBip32InfoForELA() {
3514 if (!isELA()) {
3515 return;
3516 }
3517
3518 var coin = parseIntNoNaN(DOM.bip44coin.val(), 0);
3519 var account = parseIntNoNaN(DOM.bip44account.val(), 0);
3520 var change = parseIntNoNaN(DOM.bip44change.val(), 0);
3521
22f87669
IC		 3522 DOM.extendedPrivKey.val(libs.elastosjs.getBip32ExtendedPrivateKey(seed, coin, account, change));
3523 DOM.extendedPubKey.val(libs.elastosjs.getBip32ExtendedPublicKey(seed, coin, account, change));
36523e0d
NJ		 3524
3525 // Display the addresses and privkeys
3526 clearAddressesList();
3527 var initialAddressCount = parseInt(DOM.rowsToAdd.val());
3528 displayAddresses(0, initialAddressCount);
3529 }
3530
3531 function calcAddressForELA(seed, coin, account, change, index) {
3532 if (!isELA()) {
3533 return;
3534 }
3535
22f87669 3536 var publicKey = libs.elastosjs.getDerivedPublicKey(libs.elastosjs.getMasterPublicKey(seed), change, index);
36523e0d 3537 return {
22f87669 3538 privateKey: libs.elastosjs.getDerivedPrivateKey(seed, coin, account, change, index),
36523e0d 3539 publicKey: publicKey,
22f87669 3540 address: libs.elastosjs.getAddress(publicKey.toString('hex'))
36523e0d
NJ		 3541 };
3542 }
3543 // ELA - Elastos functions - end
3544
ebd8d4e8
IC		 3545 init();
3546
3547})();
A web tool for converting BIP39 mnemonic codes