]> 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 TRX coin 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 }
b674c571 1142 //TRX is different
1143 if (networks[DOM.network.val()].name == "TRX - Tron") {
1144 var pubkeyBuffer = keyPair.getPublicKeyBuffer();
1145 var ethPubkey = libs.ethUtil.importPublic(pubkeyBuffer);
1146 var addressBuffer = libs.ethUtil.publicToAddress(ethPubkey);
1147 address = libs.bitcoin.address.toBase58Check(addressBuffer, 0x41);
1148 if (hasPrivkey) {
1149 privkey = keyPair.d.toBuffer().toString('hex');
1150 }
1151 }
c2e4f938 1152
a823e526 1153 // RSK values are different
1154 if (networkIsRsk()) {
1155 var pubkeyBuffer = keyPair.getPublicKeyBuffer();
1156 var ethPubkey = libs.ethUtil.importPublic(pubkeyBuffer);
1157 var addressBuffer = libs.ethUtil.publicToAddress(ethPubkey);
1158 var hexAddress = addressBuffer.toString('hex');
1159 // Use chainId based on selected network
1160 // Ref: https://developers.rsk.co/rsk/architecture/account-based/#chainid
1161 var chainId;
1162 var rskNetworkName = networks[DOM.network.val()].name;
1163 switch (rskNetworkName) {
1164 case "R-BTC - RSK":
1165 chainId = 30;
1166 break;
1167 case "tR-BTC - RSK Testnet":
1168 chainId = 31;
1169 break;
1170 default:
1171 chainId = null;
1172 }
1173 var checksumAddress = toChecksumAddressForRsk(hexAddress, chainId);
1174 address = libs.ethUtil.addHexPrefix(checksumAddress);
1175 pubkey = libs.ethUtil.addHexPrefix(pubkey);
1176 if (hasPrivkey) {
1177 privkey = libs.ethUtil.bufferToHex(keyPair.d.toBuffer());
1178 }
1179 }
1180
0e1fd953
JK		 1181 // Handshake values are different
1182 if (networks[DOM.network.val()].name == "HNS - Handshake") {
1183 var ring = libs.handshake.KeyRing.fromPublic(keyPair.getPublicKeyBuffer())
1184 address = ring.getAddress().toString();
1185 }
bf528f65 1186
8ffa333b
SÖ		 1187 // Stellar is different
1188 if (networks[DOM.network.val()].name == "XLM - Stellar") {
22c443df
SÖ		 1189 var purpose = parseIntNoNaN(DOM.bip44purpose.val(), 44);
1190 var coin = parseIntNoNaN(DOM.bip44coin.val(), 0);
1191 var path = "m/";
1192 path += purpose + "'/";
1193 path += coin + "'/" + index + "'";
22f87669 1194 var keypair = libs.stellarUtil.getKeypair(path, seed);
8ffa333b
SÖ		 1195 indexText = path;
1196 privkey = keypair.secret();
1197 pubkey = address = keypair.publicKey();
1198 }
7a113003 1199 if ((networks[DOM.network.val()].name == "NAS - Nebulas")) {
7a113003 1200 var privKeyBuffer = keyPair.d.toBuffer(32);
22f87669 1201 var nebulasAccount = libs.nebulas.Account.NewAccount();
491948db 1202 nebulasAccount.setPrivateKey(privKeyBuffer);
1203 address = nebulasAccount.getAddressString();
1204 privkey = nebulasAccount.getPrivateKeyString();
1205 pubkey = nebulasAccount.getPublicKeyString();
7a113003 1206 }
64a7d2aa 1207 // Ripple values are different
534481b6 1208 if (networks[DOM.network.val()].name == "XRP - Ripple") {
64a7d2aa 1209 privkey = convertRipplePriv(privkey);
1210 address = convertRippleAdrr(address);
1211 }
46a5338e
LL		 1212 // Jingtum values are different
1213 if (networks[DOM.network.val()].name == "SWTC - Jingtum") {
1214 privkey = convertJingtumPriv(privkey);
1215 address = convertJingtumAdrr(address);
1216 }
45e40c28
C		 1217 // CasinoCoin values are different
1218 if (networks[DOM.network.val()].name == "CSC - CasinoCoin") {
1219 privkey = convertCasinoCoinPriv(privkey);
1220 address = convertCasinoCoinAdrr(address);
1221 }
e0f91e20
IC		 1222 // Bitcoin Cash address format may vary
1223 if (networks[DOM.network.val()].name == "BCH - Bitcoin Cash") {
1224 var bchAddrType = DOM.bitcoinCashAddressType.filter(":checked").val();
1225 if (bchAddrType == "cashaddr") {
22f87669 1226 address = libs.bchaddr.toCashAddress(address);
e0f91e20
IC		 1227 }
1228 else if (bchAddrType == "bitpay") {
22f87669 1229 address = libs.bchaddr.toBitpayAddress(address);
e0f91e20
IC		 1230 }
1231 }
d0889ab9 1232 // Bitcoin Cash address format may vary
1233 if (networks[DOM.network.val()].name == "SLP - Simple Ledger Protocol") {
1234 var bchAddrType = DOM.bitcoinCashAddressType.filter(":checked").val();
1235 if (bchAddrType == "cashaddr") {
22f87669 1236 address = libs.bchaddrSlp.toSlpAddress(address);
d0889ab9 1237 }
1238 }
0fd67b59
IC		 1239 // Segwit addresses are different
1240 if (isSegwit) {
1241 if (!segwitAvailable) {
6c08f364
IC		 1242 return;
1243 }
c49e8812 1244 if (isP2wpkh) {
22f87669
IC		 1245 var keyhash = libs.bitcoin.crypto.hash160(key.getPublicKeyBuffer());
1246 var scriptpubkey = libs.bitcoin.script.witnessPubKeyHash.output.encode(keyhash);
1247 address = libs.bitcoin.address.fromOutputScript(scriptpubkey, network)
c49e8812
IC		 1248 }
1249 else if (isP2wpkhInP2sh) {
22f87669
IC		 1250 var keyhash = libs.bitcoin.crypto.hash160(key.getPublicKeyBuffer());
1251 var scriptsig = libs.bitcoin.script.witnessPubKeyHash.output.encode(keyhash);
1252 var addressbytes = libs.bitcoin.crypto.hash160(scriptsig);
1253 var scriptpubkey = libs.bitcoin.script.scriptHash.output.encode(addressbytes);
1254 address = libs.bitcoin.address.fromOutputScript(scriptpubkey, network)
c49e8812 1255 }
5c203fab 1256 else if (isP2wsh) {
22f87669 1257 // https://github.com/libs.bitcoinjs-lib/blob/v3.3.2/test/integration/addresses.js#L71
f7e9fdf0 1258 // This is a 1-of-1
22f87669
IC		 1259 var witnessScript = libs.bitcoin.script.multisig.output.encode(1, [key.getPublicKeyBuffer()]);
1260 var scriptPubKey = libs.bitcoin.script.witnessScriptHash.output.encode(libs.bitcoin.crypto.sha256(witnessScript));
1261 address = libs.bitcoin.address.fromOutputScript(scriptPubKey, network);
5c203fab
IC		 1262 }
1263 else if (isP2wshInP2sh) {
22f87669 1264 // https://github.com/libs.bitcoinjs-lib/blob/v3.3.2/test/integration/transactions.js#L183
f7e9fdf0 1265 // This is a 1-of-1
22f87669
IC		 1266 var witnessScript = libs.bitcoin.script.multisig.output.encode(1, [key.getPublicKeyBuffer()]);
1267 var redeemScript = libs.bitcoin.script.witnessScriptHash.output.encode(libs.bitcoin.crypto.sha256(witnessScript));
1268 var scriptPubKey = libs.bitcoin.script.scriptHash.output.encode(libs.bitcoin.crypto.hash160(redeemScript));
1269 address = libs.bitcoin.address.fromOutputScript(scriptPubKey, network)
5c203fab 1270 }
6c08f364 1271 }
b85da074 1272
bf13c95f 1273 if ((networks[DOM.network.val()].name == "CRW - Crown")) {
22f87669 1274 address = libs.bitcoin.networks.crown.toNewAddress(address);
bf13c95f 1275 }
b85da074 1276
7d68d547 1277 if (networks[DOM.network.val()].name == "EOS - EOSIO") {
3451d1a8 1278 address = ""
5c6e875f
JU		 1279 pubkey = EOSbufferToPublic(keyPair.getPublicKeyBuffer());
1280 privkey = EOSbufferToPrivate(keyPair.d.toBuffer(32));
3451d1a8 1281 }
82e3938a 1282
d1d8699f
SA		 1283 if (networks[DOM.network.val()].name == "FIO - Foundation for Interwallet Operability") {
1284 address = ""
1285 pubkey = FIObufferToPublic(keyPair.getPublicKeyBuffer());
1286 privkey = FIObufferToPrivate(keyPair.d.toBuffer(32));
1287 }
1288
76120cb0
H		 1289 //Groestlcoin Addresses are different
1290 if(isGRS()) {
1291
1292 if (isSegwit) {
1293 if (!segwitAvailable) {
1294 return;
1295 }
1296 if (isP2wpkh) {
22f87669 1297 address = libs.groestlcoinjs.address.fromOutputScript(scriptpubkey, network)
76120cb0
H		 1298 }
1299 else if (isP2wpkhInP2sh) {
22f87669 1300 address = libs.groestlcoinjs.address.fromOutputScript(scriptpubkey, network)
76120cb0 1301 }
75138bee 1302 }
76120cb0
H		 1303 //non-segwit addresses are handled by using groestlcoinjs for bip32RootKey
1304 }
1305
36523e0d
NJ		 1306 if (isELA()) {
1307 let elaAddress = calcAddressForELA(
1308 seed,
1309 parseIntNoNaN(DOM.bip44coin.val(), 0),
1310 parseIntNoNaN(DOM.bip44account.val(), 0),
1311 parseIntNoNaN(DOM.bip44change.val(), 0),
1312 index
1313 );
1314 address = elaAddress.address;
1315 privkey = elaAddress.privateKey;
1316 pubkey = elaAddress.publicKey;
1317 }
1318
1b12b2f5 1319 addAddressToList(indexText, address, pubkey, privkey);
0eda54f5
IC		 1320 if (isLast) {
1321 hidePending();
a78f4e28 1322 updateCsv();
0eda54f5 1323 }
a8c45487
IC		 1324 }, 50)
1325 }
1326
1327 init();
1328
1329 }
1330
ebd8d4e8 1331 function showMore() {
ebd8d4e8
IC		 1332 var rowsToAdd = parseInt(DOM.rowsToAdd.val());
1333 if (isNaN(rowsToAdd)) {
1334 rowsToAdd = 20;
1335 DOM.rowsToAdd.val("20");
1336 }
9183f9f6
IC		 1337 var start = parseInt(DOM.moreRowsStartIndex.val())
1338 if (isNaN(start)) {
1339 start = lastIndexInTable() + 1;
1340 }
1341 else {
1342 var newStart = start + rowsToAdd;
1343 DOM.moreRowsStartIndex.val(newStart);
1344 }
ebd8d4e8
IC		 1345 if (rowsToAdd > 200) {
1346 var msg = "Generating " + rowsToAdd + " rows could take a while. ";
1347 msg += "Do you want to continue?";
1348 if (!confirm(msg)) {
1349 return;
1350 }
1351 }
ebd8d4e8 1352 displayAddresses(start, rowsToAdd);
ebd8d4e8
IC		 1353 }
1354
1355 function clearDisplay() {
1356 clearAddressesList();
fa2e4e93 1357 clearKeys();
ebd8d4e8
IC		 1358 hideValidationError();
1359 }
1360
1361 function clearAddressesList() {
1362 DOM.addresses.empty();
a78f4e28 1363 DOM.csv.val("");
40892aba
IC		 1364 stopGenerating();
1365 }
1366
1367 function stopGenerating() {
1368 while (generationProcesses.length > 0) {
1369 var generation = generationProcesses.shift();
1370 generation.stop();
1371 }
ebd8d4e8
IC		 1372 }
1373
fa2e4e93
IC		 1374 function clearKeys() {
1375 clearRootKey();
1376 clearDerivedKeys();
1377 }
1378
1379 function clearRootKey() {
ebd8d4e8 1380 DOM.rootKey.val("");
fa2e4e93
IC		 1381 }
1382
1383 function clearDerivedKeys() {
ebd8d4e8
IC		 1384 DOM.extendedPrivKey.val("");
1385 DOM.extendedPubKey.val("");
fa2e4e93
IC		 1386 DOM.bip44accountXprv.val("");
1387 DOM.bip44accountXpub.val("");
ebd8d4e8
IC		 1388 }
1389
1b12b2f5 1390 function addAddressToList(indexText, address, pubkey, privkey) {
ebd8d4e8 1391 var row = $(addressRowTemplate.html());
700901cd
IC		 1392 // Elements
1393 var indexCell = row.find(".index span");
1394 var addressCell = row.find(".address span");
1b12b2f5 1395 var pubkeyCell = row.find(".pubkey span");
700901cd
IC		 1396 var privkeyCell = row.find(".privkey span");
1397 // Content
ae30fed8 1398 indexCell.text(indexText);
700901cd 1399 addressCell.text(address);
1b12b2f5 1400 pubkeyCell.text(pubkey);
700901cd
IC		 1401 privkeyCell.text(privkey);
1402 // Visibility
1403 if (!showIndex) {
1404 indexCell.addClass("invisible");
1405 }
1406 if (!showAddress) {
1407 addressCell.addClass("invisible");
1408 }
1b12b2f5
IC		 1409 if (!showPubKey) {
1410 pubkeyCell.addClass("invisible");
1411 }
700901cd 1412 if (!showPrivKey) {
6d628db7 1413 privkeyCell.addClass("invisible");
700901cd 1414 }
ebd8d4e8 1415 DOM.addresses.append(row);
e00964cc
IC		 1416 var rowShowQrEls = row.find("[data-show-qr]");
1417 setQrEvents(rowShowQrEls);
ebd8d4e8
IC		 1418 }
1419
1420 function hasStrongRandom() {
1421 return 'crypto' in window && window['crypto'] !== null;
1422 }
1423
1424 function disableForms() {
1425 $("form").on("submit", function(e) {
1426 e.preventDefault();
1427 });
1428 }
1429
ebd8d4e8
IC		 1430 function parseIntNoNaN(val, defaultVal) {
1431 var v = parseInt(val);
1432 if (isNaN(v)) {
1433 return defaultVal;
1434 }
1435 return v;
1436 }
1437
1438 function showPending() {
1439 DOM.feedback
1440 .text("Calculating...")
1441 .show();
1442 }
1443
563e401a 1444 function findNearestWord(word) {
5ee7bb9e
IC		 1445 var language = getLanguage();
1446 var words = WORDLISTS[language];
563e401a
IC		 1447 var minDistance = 99;
1448 var closestWord = words[0];
1449 for (var i=0; i<words.length; i++) {
1450 var comparedTo = words[i];
6ea15134
IC		 1451 if (comparedTo.indexOf(word) == 0) {
1452 return comparedTo;
1453 }
22f87669 1454 var distance = libs.levenshtein.get(word, comparedTo);
563e401a
IC		 1455 if (distance < minDistance) {
1456 closestWord = comparedTo;
1457 minDistance = distance;
1458 }
1459 }
1460 return closestWord;
1461 }
1462
ebd8d4e8
IC		 1463 function hidePending() {
1464 DOM.feedback
1465 .text("")
1466 .hide();
1467 }
1468
7f15cb6e
IC		 1469 function populateNetworkSelect() {
1470 for (var i=0; i<networks.length; i++) {
1471 var network = networks[i];
1472 var option = $("<option>");
1473 option.attr("value", i);
1474 option.text(network.name);
7b742f87
IC		 1475 if (network.name == "BTC - Bitcoin") {
1476 option.prop("selected", true);
1477 }
7f15cb6e
IC		 1478 DOM.phraseNetwork.append(option);
1479 }
1480 }
29bf60f5 1481
b4fd763c
AG		 1482 function populateClientSelect() {
1483 for (var i=0; i<clients.length; i++) {
1484 var client = clients[i];
1485 var option = $("<option>");
1486 option.attr("value", i);
1487 option.text(client.name);
29bf60f5 1488 DOM.bip32Client.append(option);
b4fd763c
AG		 1489 }
1490 }
7f15cb6e 1491
5ee7bb9e
IC		 1492 function getLanguage() {
1493 var defaultLanguage = "english";
1494 // Try to get from existing phrase
1495 var language = getLanguageFromPhrase();
1496 // Try to get from url if not from phrase
1497 if (language.length == 0) {
1498 language = getLanguageFromUrl();
1499 }
1500 // Default to English if no other option
1501 if (language.length == 0) {
1502 language = defaultLanguage;
1503 }
1504 return language;
1505 }
1506
1507 function getLanguageFromPhrase(phrase) {
1508 // Check if how many words from existing phrase match a language.
1509 var language = "";
1510 if (!phrase) {
1511 phrase = DOM.phrase.val();
1512 }
1513 if (phrase.length > 0) {
1514 var words = phraseToWordArray(phrase);
1515 var languageMatches = {};
1516 for (l in WORDLISTS) {
1517 // Track how many words match in this language
1518 languageMatches[l] = 0;
1519 for (var i=0; i<words.length; i++) {
1520 var wordInLanguage = WORDLISTS[l].indexOf(words[i]) > -1;
1521 if (wordInLanguage) {
1522 languageMatches[l]++;
1523 }
1524 }
1525 // Find languages with most word matches.
1526 // This is made difficult due to commonalities between Chinese
1527 // simplified vs traditional.
1528 var mostMatches = 0;
1529 var mostMatchedLanguages = [];
1530 for (var l in languageMatches) {
1531 var numMatches = languageMatches[l];
1532 if (numMatches > mostMatches) {
1533 mostMatches = numMatches;
1534 mostMatchedLanguages = [l];
1535 }
1536 else if (numMatches == mostMatches) {
1537 mostMatchedLanguages.push(l);
1538 }
1539 }
1540 }
1541 if (mostMatchedLanguages.length > 0) {
1542 // Use first language and warn if multiple detected
1543 language = mostMatchedLanguages[0];
1544 if (mostMatchedLanguages.length > 1) {
1545 console.warn("Multiple possible languages");
1546 console.warn(mostMatchedLanguages);
1547 }
1548 }
1549 }
1550 return language;
1551 }
1552
1553 function getLanguageFromUrl() {
c6624d51
IC		 1554 for (var language in WORDLISTS) {
1555 if (window.location.hash.indexOf(language) > -1) {
1556 return language;
1557 }
1558 }
1559 return "";
5ee7bb9e
IC		 1560 }
1561
1562 function setMnemonicLanguage() {
1563 var language = getLanguage();
1564 // Load the bip39 mnemonic generator for this language if required
1565 if (!(language in mnemonics)) {
1566 mnemonics[language] = new Mnemonic(language);
1567 }
1568 mnemonic = mnemonics[language];
1569 }
1570
1571 function convertPhraseToNewLanguage() {
1572 var oldLanguage = getLanguageFromPhrase();
1573 var newLanguage = getLanguageFromUrl();
1574 var oldPhrase = DOM.phrase.val();
1575 var oldWords = phraseToWordArray(oldPhrase);
1576 var newWords = [];
1577 for (var i=0; i<oldWords.length; i++) {
1578 var oldWord = oldWords[i];
1579 var index = WORDLISTS[oldLanguage].indexOf(oldWord);
1580 var newWord = WORDLISTS[newLanguage][index];
1581 newWords.push(newWord);
1582 }
1583 newPhrase = wordArrayToPhrase(newWords);
1584 return newPhrase;
1585 }
1586
1587 // TODO look at jsbip39 - mnemonic.splitWords
1588 function phraseToWordArray(phrase) {
1589 var words = phrase.split(/\s/g);
1590 var noBlanks = [];
1591 for (var i=0; i<words.length; i++) {
1592 var word = words[i];
1593 if (word.length > 0) {
1594 noBlanks.push(word);
1595 }
1596 }
1597 return noBlanks;
1598 }
1599
1600 // TODO look at jsbip39 - mnemonic.joinWords
1601 function wordArrayToPhrase(words) {
1602 var phrase = words.join(" ");
1603 var language = getLanguageFromPhrase(phrase);
956e44ef 1604 if (language == "japanese") {
5ee7bb9e
IC		 1605 phrase = words.join("\u3000");
1606 }
1607 return phrase;
1608 }
96ee8ab0
IC		 1609
1610 function writeSplitPhrase(phrase) {
d93f2ba9
IC		 1611 var wordCount = phrase.split(/\s/g).length;
1612 var left=[];
1613 for (var i=0;i<wordCount;i++) left.push(i);
1614 var group=[[],[],[]],
1615 groupI=-1;
1616 var seed = Math.abs(sjcl.hash.sha256.hash(phrase)[0])% 2147483647;
1617 while (left.length>0) {
1618 groupI=(groupI+1)%3;
1619 seed = seed * 16807 % 2147483647;
1620 var selected=Math.floor(left.length*(seed - 1) / 2147483646);
1621 group[groupI].push(left[selected]);
1622 left.splice(selected,1);
1623 }
1624 var cards=[phrase.split(/\s/g),phrase.split(/\s/g),phrase.split(/\s/g)];
1625 for (var i=0;i<3;i++) {
1626 for (var ii=0;ii<wordCount/3;ii++) cards[i][group[i][ii]]='XXXX';
1627 cards[i]='Card '+(i+1)+': '+wordArrayToPhrase(cards[i]);
1628 }
f8fae68e 1629 DOM.phraseSplit.val(cards.join("\r\n"));
d93f2ba9
IC		 1630 var triesPerSecond=10000000000;
1631 var hackTime=Math.pow(2,wordCount*10/3)/triesPerSecond;
ea2cb91a 1632 var displayRedText = false;
96ee8ab0
IC		 1633 if (hackTime<1) {
1634 hackTime="<1 second";
ea2cb91a 1635 displayRedText = true;
96ee8ab0
IC		 1636 } else if (hackTime<86400) {
1637 hackTime=Math.floor(hackTime)+" seconds";
ea2cb91a 1638 displayRedText = true;
96ee8ab0
IC		 1639 } else if(hackTime<31557600) {
1640 hackTime=Math.floor(hackTime/86400)+" days";
ea2cb91a 1641 displayRedText = true;
96ee8ab0
IC		 1642 } else {
1643 hackTime=Math.floor(hackTime/31557600)+" years";
1644 }
1645 DOM.phraseSplitWarn.html("Time to hack with only one card: "+hackTime);
ea2cb91a
IC		 1646 if (displayRedText) {
1647 DOM.phraseSplitWarn.addClass("text-danger");
1648 } else {
1649 DOM.phraseSplitWarn.removeClass("text-danger");
1650 }
96ee8ab0 1651 }
5ee7bb9e 1652
c6624d51
IC		 1653 function isUsingOwnEntropy() {
1654 return DOM.useEntropy.prop("checked");
1655 }
1656
1657 function setMnemonicFromEntropy() {
0a84fe6a 1658 clearEntropyFeedback();
057722b0 1659 // Get entropy value
c6624d51 1660 var entropyStr = DOM.entropy.val();
057722b0 1661 // Work out minimum base for entropy
516c16d7
IC		 1662 var entropy = null;
1663 if (entropyTypeAutoDetect) {
1664 entropy = Entropy.fromString(entropyStr);
1665 }
1666 else {
1667 let base = DOM.entropyTypeInputs.filter(":checked").val();
1668 entropy = Entropy.fromString(entropyStr, base);
1669 }
057722b0 1670 if (entropy.binaryStr.length == 0) {
c6624d51
IC		 1671 return;
1672 }
1673 // Show entropy details
1cf1bbaf 1674 showEntropyFeedback(entropy);
3599674d
IC		 1675 // Use entropy hash if not using raw entropy
1676 var bits = entropy.binaryStr;
1677 var mnemonicLength = DOM.entropyMnemonicLength.val();
1678 if (mnemonicLength != "raw") {
1679 // Get bits by hashing entropy with SHA256
1680 var hash = sjcl.hash.sha256.hash(entropy.cleanStr);
1681 var hex = sjcl.codec.hex.fromBits(hash);
22f87669 1682 bits = libs.BigInteger.BigInteger.parse(hex, 16).toString(2);
53aaab27 1683 while (bits.length % 256 != 0) {
3599674d
IC		 1684 bits = "0" + bits;
1685 }
1686 // Truncate hash to suit number of words
1687 mnemonicLength = parseInt(mnemonicLength);
1688 var numberOfBits = 32 * mnemonicLength / 3;
1689 bits = bits.substring(0, numberOfBits);
645945a0
IC		 1690 // show warning for weak entropy override
1691 if (mnemonicLength / 3 * 32 > entropy.binaryStr.length) {
1692 DOM.entropyWeakEntropyOverrideWarning.removeClass("hidden");
1693 }
1694 else {
1695 DOM.entropyWeakEntropyOverrideWarning.addClass("hidden");
1696 }
1697 }
1698 else {
1699 // hide warning for weak entropy override
1700 DOM.entropyWeakEntropyOverrideWarning.addClass("hidden");
3599674d 1701 }
c6624d51 1702 // Discard trailing entropy
3599674d 1703 var bitsToUse = Math.floor(bits.length / 32) * 32;
d6fd8ebf
IC		 1704 var start = bits.length - bitsToUse;
1705 var binaryStr = bits.substring(start);
c6624d51
IC		 1706 // Convert entropy string to numeric array
1707 var entropyArr = [];
adc8ce12
IC		 1708 for (var i=0; i<binaryStr.length / 8; i++) {
1709 var byteAsBits = binaryStr.substring(i*8, i*8+8);
1710 var entropyByte = parseInt(byteAsBits, 2);
c6624d51
IC		 1711 entropyArr.push(entropyByte)
1712 }
1713 // Convert entropy array to mnemonic
1714 var phrase = mnemonic.toMnemonic(entropyArr);
1715 // Set the mnemonic in the UI
1716 DOM.phrase.val(phrase);
96ee8ab0 1717 writeSplitPhrase(phrase);
74ab4cbe
IC		 1718 // Show the word indexes
1719 showWordIndexes();
09d63290
IC		 1720 // Show the checksum
1721 showChecksum();
c6624d51
IC		 1722 }
1723
0a84fe6a 1724 function clearEntropyFeedback() {
20f459ce 1725 DOM.entropyCrackTime.text("...");
1cf1bbaf 1726 DOM.entropyType.text("");
0a84fe6a
IC		 1727 DOM.entropyWordCount.text("0");
1728 DOM.entropyEventCount.text("0");
1729 DOM.entropyBitsPerEvent.text("0");
1730 DOM.entropyBits.text("0");
1731 DOM.entropyFiltered.html("&nbsp;");
1732 DOM.entropyBinary.html("&nbsp;");
c6624d51
IC		 1733 }
1734
1cf1bbaf 1735 function showEntropyFeedback(entropy) {
6422c1cd 1736 var numberOfBits = entropy.binaryStr.length;
20f459ce 1737 var timeToCrack = "unknown";
9bc39377 1738 try {
22f87669 1739 var z = libs.zxcvbn(entropy.base.parts.join(""));
20f459ce
IC		 1740 timeToCrack = z.crack_times_display.offline_fast_hashing_1e10_per_second;
1741 if (z.feedback.warning != "") {
1742 timeToCrack = timeToCrack + " - " + z.feedback.warning;
1743 };
9bc39377
IC		 1744 }
1745 catch (e) {
9bc39377
IC		 1746 console.log("Error detecting entropy strength with zxcvbn:");
1747 console.log(e);
b299a6a7 1748 }
391c7f26 1749 var entropyTypeStr = getEntropyTypeStr(entropy);
516c16d7
IC		 1750 DOM.entropyTypeInputs.attr("checked", false);
1751 DOM.entropyTypeInputs.filter("[value='" + entropyTypeStr + "']").attr("checked", true);
6422c1cd 1752 var wordCount = Math.floor(numberOfBits / 32) * 3;
94959756 1753 var bitsPerEvent = entropy.bitsPerEvent.toFixed(2);
f8ca25c3 1754 var spacedBinaryStr = addSpacesEveryElevenBits(entropy.binaryStr);
b54c1218 1755 DOM.entropyFiltered.html(entropy.cleanHtml);
391c7f26 1756 DOM.entropyType.text(entropyTypeStr);
20f459ce 1757 DOM.entropyCrackTime.text(timeToCrack);
1cf1bbaf 1758 DOM.entropyEventCount.text(entropy.base.ints.length);
6422c1cd 1759 DOM.entropyBits.text(numberOfBits);
0a84fe6a 1760 DOM.entropyWordCount.text(wordCount);
d6cade86 1761 DOM.entropyBinary.text(spacedBinaryStr);
6422c1cd 1762 DOM.entropyBitsPerEvent.text(bitsPerEvent);
ee0981f1
IC		 1763 // detect and warn of filtering
1764 var rawNoSpaces = DOM.entropy.val().replace(/\s/g, "");
1765 var cleanNoSpaces = entropy.cleanStr.replace(/\s/g, "");
1766 var isFiltered = rawNoSpaces.length != cleanNoSpaces.length;
1767 if (isFiltered) {
1768 DOM.entropyFilterWarning.removeClass('hidden');
1769 }
1770 else {
1771 DOM.entropyFilterWarning.addClass('hidden');
1772 }
02f05d3e
IC		 1773 }
1774
391c7f26
IC		 1775 function getEntropyTypeStr(entropy) {
1776 var typeStr = entropy.base.str;
1777 // Add some detail if these are cards
1778 if (entropy.base.asInt == 52) {
1779 var cardDetail = []; // array of message strings
1780 // Detect duplicates
1781 var dupes = [];
1782 var dupeTracker = {};
1783 for (var i=0; i<entropy.base.parts.length; i++) {
1784 var card = entropy.base.parts[i];
5c653a12
IC		 1785 var cardUpper = card.toUpperCase();
1786 if (cardUpper in dupeTracker) {
391c7f26
IC		 1787 dupes.push(card);
1788 }
5c653a12 1789 dupeTracker[cardUpper] = true;
391c7f26
IC		 1790 }
1791 if (dupes.length > 0) {
1792 var dupeWord = "duplicates";
1793 if (dupes.length == 1) {
1794 dupeWord = "duplicate";
1795 }
1796 var msg = dupes.length + " " + dupeWord + ": " + dupes.slice(0,3).join(" ");
1797 if (dupes.length > 3) {
1798 msg += "...";
1799 }
1800 cardDetail.push(msg);
1801 }
1802 // Detect full deck
1803 var uniqueCards = [];
1804 for (var uniqueCard in dupeTracker) {
1805 uniqueCards.push(uniqueCard);
1806 }
1807 if (uniqueCards.length == 52) {
1808 cardDetail.unshift("full deck");
1809 }
bbc29c80
IC		 1810 // Detect missing cards
1811 var values = "A23456789TJQK";
1812 var suits = "CDHS";
1813 var missingCards = [];
1814 for (var i=0; i<suits.length; i++) {
1815 for (var j=0; j<values.length; j++) {
1816 var card = values[j] + suits[i];
1817 if (!(card in dupeTracker)) {
1818 missingCards.push(card);
1819 }
1820 }
1821 }
1822 // Display missing cards if six or less, ie clearly going for full deck
1823 if (missingCards.length > 0 && missingCards.length <= 6) {
1824 var msg = missingCards.length + " missing: " + missingCards.slice(0,3).join(" ");
1825 if (missingCards.length > 3) {
1826 msg += "...";
1827 }
1828 cardDetail.push(msg);
1829 }
391c7f26
IC		 1830 // Add card details to typeStr
1831 if (cardDetail.length > 0) {
1832 typeStr += " (" + cardDetail.join(", ") + ")";
1833 }
1834 }
1835 return typeStr;
1836 }
1837
e00964cc
IC		 1838 function setQrEvents(els) {
1839 els.on("mouseenter", createQr);
1840 els.on("mouseleave", destroyQr);
1841 els.on("click", toggleQr);
1842 }
1843
1844 function createQr(e) {
1845 var content = e.target.textContent || e.target.value;
1846 if (content) {
22f87669 1847 var qrEl = libs.kjua({
9225b805
IC		 1848 text: content,
1849 render: "canvas",
1850 size: 310,
1851 ecLevel: 'H',
1852 });
1853 DOM.qrImage.append(qrEl);
e00964cc 1854 if (!showQr) {
97811c29
IC		 1855 DOM.qrHider.addClass("hidden");
1856 }
1857 else {
1858 DOM.qrHider.removeClass("hidden");
e00964cc
IC		 1859 }
1860 DOM.qrContainer.removeClass("hidden");
1861 }
1862 }
1863
1864 function destroyQr() {
1865 DOM.qrImage.text("");
1866 DOM.qrContainer.addClass("hidden");
1867 }
1868
1869 function toggleQr() {
1870 showQr = !showQr;
97811c29 1871 DOM.qrHider.toggleClass("hidden");
e00964cc
IC		 1872 DOM.qrHint.toggleClass("hidden");
1873 }
1874
32fab2c3
IC		 1875 function bip44TabSelected() {
1876 return DOM.bip44tab.hasClass("active");
1877 }
1878
1879 function bip32TabSelected() {
1880 return DOM.bip32tab.hasClass("active");
1881 }
1882
44e705cd
IB		 1883 function networkIsEthereum() {
1884 var name = networks[DOM.network.val()].name;
1885 return (name == "ETH - Ethereum")
1886 || (name == "ETC - Ethereum Classic")
90929701 1887 || (name == "EWT - EnergyWeb")
44e705cd
IB		 1888 || (name == "PIRL - Pirl")
1889 || (name == "MIX - MIX")
46a5338e 1890 || (name == "MOAC - MOAC")
44e705cd
IB		 1891 || (name == "MUSIC - Musicoin")
1892 || (name == "POA - Poa")
1893 || (name == "EXP - Expanse")
1894 || (name == "CLO - Callisto")
1895 || (name == "DXN - DEXON")
1896 || (name == "ELLA - Ellaism")
1897 || (name == "ESN - Ethersocial Network")
1898 || (name == "VET - VeChain")
8131a071 1899 || (name == "ERE - EtherCore")
44e705cd
IB		 1900 }
1901
a823e526 1902 function networkIsRsk() {
1903 var name = networks[DOM.network.val()].name;
1904 return (name == "R-BTC - RSK")
1905 || (name == "tR-BTC - RSK Testnet");
1906 }
1907
0fd67b59 1908 function networkHasSegwit() {
c147cb5e
IC		 1909 var n = network;
1910 if ("baseNetwork" in network) {
22f87669 1911 n = libs.bitcoin.networks[network.baseNetwork];
c147cb5e
IC		 1912 }
1913 // check if only p2wpkh params are required
1914 if (p2wpkhSelected()) {
1915 return "p2wpkh" in n;
1916 }
1917 // check if only p2wpkh-in-p2sh params are required
1918 else if (p2wpkhInP2shSelected()) {
1919 return "p2wpkhInP2sh" in n;
1920 }
1921 // require both if it's unclear which params are required
1922 return "p2wpkh" in n && "p2wpkhInP2sh" in n;
6c08f364
IC		 1923 }
1924
1925 function bip49TabSelected() {
1926 return DOM.bip49tab.hasClass("active");
1927 }
1928
4e9b492c
IC		 1929 function bip84TabSelected() {
1930 return DOM.bip84tab.hasClass("active");
1931 }
1932
c49e8812
IC		 1933 function bip141TabSelected() {
1934 return DOM.bip141tab.hasClass("active");
1935 }
1936
6c08f364
IC		 1937 function setHdCoin(coinValue) {
1938 DOM.bip44coin.val(coinValue);
1939 DOM.bip49coin.val(coinValue);
4e9b492c 1940 DOM.bip84coin.val(coinValue);
6c08f364
IC		 1941 }
1942
0fd67b59 1943 function showSegwitAvailable() {
6c08f364
IC		 1944 DOM.bip49unavailable.addClass("hidden");
1945 DOM.bip49available.removeClass("hidden");
bddd5d9f
IC		 1946 DOM.bip84unavailable.addClass("hidden");
1947 DOM.bip84available.removeClass("hidden");
c49e8812
IC		 1948 DOM.bip141unavailable.addClass("hidden");
1949 DOM.bip141available.removeClass("hidden");
6c08f364
IC		 1950 }
1951
0fd67b59 1952 function showSegwitUnavailable() {
6c08f364
IC		 1953 DOM.bip49available.addClass("hidden");
1954 DOM.bip49unavailable.removeClass("hidden");
bddd5d9f
IC		 1955 DOM.bip84available.addClass("hidden");
1956 DOM.bip84unavailable.removeClass("hidden");
c49e8812
IC		 1957 DOM.bip141available.addClass("hidden");
1958 DOM.bip141unavailable.removeClass("hidden");
6c08f364
IC		 1959 }
1960
0fd67b59
IC		 1961 function adjustNetworkForSegwit() {
1962 // If segwit is selected the xpub/xprv prefixes need to be adjusted
93c3ef47
IC		 1963 // to avoid accidentally importing BIP49 xpub to BIP44 watch only
1964 // wallet.
1965 // See https://github.com/iancoleman/bip39/issues/125
c49e8812
IC		 1966 var segwitNetworks = null;
1967 // if a segwit network is alread selected, need to use base network to
1968 // look up new parameters
1969 if ("baseNetwork" in network) {
22f87669 1970 network = libs.bitcoin.networks[network.baseNetwork];
c49e8812
IC		 1971 }
1972 // choose the right segwit params
1973 if (p2wpkhSelected() && "p2wpkh" in network) {
1974 network = network.p2wpkh;
1975 }
1976 else if (p2wpkhInP2shSelected() && "p2wpkhInP2sh" in network) {
1977 network = network.p2wpkhInP2sh;
93c3ef47 1978 }
5c203fab
IC		 1979 else if (p2wshSelected() && "p2wsh" in network) {
1980 network = network.p2wsh;
1981 }
1982 else if (p2wshInP2shSelected() && "p2wshInP2sh" in network) {
1983 network = network.p2wshInP2sh;
1984 }
93c3ef47
IC		 1985 }
1986
9183f9f6
IC		 1987 function lastIndexInTable() {
1988 var pathText = DOM.addresses.find(".index").last().text();
1989 var pathBits = pathText.split("/");
1990 var lastBit = pathBits[pathBits.length-1];
1991 var lastBitClean = lastBit.replace("'", "");
1992 return parseInt(lastBitClean);
1993 }
1994
74ab4cbe
IC		 1995 function uint8ArrayToHex(a) {
1996 var s = ""
1997 for (var i=0; i<a.length; i++) {
1998 var h = a[i].toString(16);
1999 while (h.length < 2) {
2000 h = "0" + h;
2001 }
2002 s = s + h;
2003 }
2004 return s;
2005 }
2006
2007 function showWordIndexes() {
2008 var phrase = DOM.phrase.val();
2009 var words = phraseToWordArray(phrase);
2010 var wordIndexes = [];
2011 var language = getLanguage();
2012 for (var i=0; i<words.length; i++) {
2013 var word = words[i];
2014 var wordIndex = WORDLISTS[language].indexOf(word);
2015 wordIndexes.push(wordIndex);
2016 }
2017 var wordIndexesStr = wordIndexes.join(", ");
2018 DOM.entropyWordIndexes.text(wordIndexesStr);
2019 }
a78f4e28 2020
09d63290
IC		 2021 function showChecksum() {
2022 var phrase = DOM.phrase.val();
2023 var words = phraseToWordArray(phrase);
2024 var checksumBitlength = words.length / 3;
2025 var checksum = "";
2026 var binaryStr = "";
2027 var language = getLanguage();
2028 for (var i=words.length-1; i>=0; i--) {
2029 var word = words[i];
2030 var wordIndex = WORDLISTS[language].indexOf(word);
2031 var wordBinary = wordIndex.toString(2);
2032 while (wordBinary.length < 11) {
2033 wordBinary = "0" + wordBinary;
2034 }
2035 var binaryStr = wordBinary + binaryStr;
2036 if (binaryStr.length >= checksumBitlength) {
2037 var start = binaryStr.length - checksumBitlength;
2038 var end = binaryStr.length;
2039 checksum = binaryStr.substring(start, end);
f8ca25c3
IC		 2040 // add spaces so the last group is 11 bits, not the first
2041 checksum = checksum.split("").reverse().join("")
2042 checksum = addSpacesEveryElevenBits(checksum);
2043 checksum = checksum.split("").reverse().join("")
2044 break;
09d63290
IC		 2045 }
2046 }
2047 DOM.entropyChecksum.text(checksum);
2048 }
2049
a78f4e28
IC		 2050 function updateCsv() {
2051 var tableCsv = "path,address,public key,private key\n";
2052 var rows = DOM.addresses.find("tr");
2053 for (var i=0; i<rows.length; i++) {
2054 var row = $(rows[i]);
2055 var cells = row.find("td");
2056 for (var j=0; j<cells.length; j++) {
2057 var cell = $(cells[j]);
2058 if (!cell.children().hasClass("invisible")) {
2059 tableCsv = tableCsv + cell.text();
2060 }
2061 if (j != cells.length - 1) {
2062 tableCsv = tableCsv + ",";
2063 }
2064 }
2065 tableCsv = tableCsv + "\n";
2066 }
2067 DOM.csv.val(tableCsv);
2068 }
74ab4cbe 2069
f8ca25c3
IC		 2070 function addSpacesEveryElevenBits(binaryStr) {
2071 return binaryStr.match(/.{1,11}/g).join(" ");
2072 }
2073
7f15cb6e 2074 var networks = [
85f762c9 2075 {
2076 name: "AC - Asiacoin",
85f762c9 2077 onSelect: function() {
22f87669 2078 network = libs.bitcoin.networks.asiacoin;
85f762c9 2079 setHdCoin(51);
2080 },
2081 },
2082 {
2083 name: "ACC - Adcoin",
85f762c9 2084 onSelect: function() {
22f87669 2085 network = libs.bitcoin.networks.adcoin;
85f762c9 2086 setHdCoin(161);
2087 },
2088 },
46054e44
OS		 2089 {
2090 name: "AGM - Argoneum",
2091 onSelect: function() {
2092 network = libs.bitcoin.networks.argoneum;
2093 setHdCoin(421);
2094 },
2095 },
31264e8b
PT		 2096 {
2097 name: "ARYA - Aryacoin",
2098 onSelect: function() {
22f87669 2099 network = libs.bitcoin.networks.aryacoin;
31264e8b
PT		 2100 setHdCoin(357);
2101 },
2102 },
85f762c9 2103 {
2104 name: "AUR - Auroracoin",
85f762c9 2105 onSelect: function() {
22f87669 2106 network = libs.bitcoin.networks.auroracoin;
85f762c9 2107 setHdCoin(85);
2108 },
2109 },
cfc0c4d7 2110 {
2111 name: "AXE - Axe",
cfc0c4d7 2112 onSelect: function() {
22f87669 2113 network = libs.bitcoin.networks.axe;
7d9b5f68 2114 setHdCoin(4242);
cfc0c4d7 2115 },
96ee8ab0
IC		 2116 },
2117 {
45588661
KP		 2118 name: "ANON - ANON",
2119 onSelect: function() {
22f87669 2120 network = libs.bitcoin.networks.anon;
45588661
KP		 2121 setHdCoin(220);
2122 },
cfc0c4d7 2123 },
3e7b1ac9
JLE		 2124 {
2125 name: "BOLI - Bolivarcoin",
2126 onSelect: function() {
22f87669 2127 network = libs.bitcoin.networks.bolivarcoin;
3e7b1ac9
JLE		 2128 setHdCoin(278);
2129 },
2130 },
85f762c9 2131 {
2132 name: "BCA - Bitcoin Atom",
85f762c9 2133 onSelect: function() {
22f87669 2134 network = libs.bitcoin.networks.atom;
85f762c9 2135 setHdCoin(185);
2136 },
2137 },
52d698e4 2138 {
2eab7c32 2139 name: "BCH - Bitcoin Cash",
52d698e4 2140 onSelect: function() {
e0f91e20 2141 DOM.bitcoinCashAddressTypeContainer.removeClass("hidden");
2eab7c32 2142 setHdCoin(145);
52d698e4 2143 },
2144 },
daab55dc 2145 {
2eab7c32 2146 name: "BEET - Beetlecoin",
daab55dc 2147 onSelect: function() {
22f87669 2148 network = libs.bitcoin.networks.beetlecoin;
2eab7c32 2149 setHdCoin(800);
daab55dc
IC		 2150 },
2151 },
85f762c9 2152 {
2153 name: "BELA - Belacoin",
85f762c9 2154 onSelect: function() {
22f87669 2155 network = libs.bitcoin.networks.belacoin;
85f762c9 2156 setHdCoin(73);
2157 },
2158 },
892ce76f
IC		 2159 {
2160 name: "BLK - BlackCoin",
892ce76f 2161 onSelect: function() {
22f87669 2162 network = libs.bitcoin.networks.blackcoin;
892ce76f
IC		 2163 setHdCoin(10);
2164 },
2165 },
6f435817
U		 2166 {
2167 name: "BND - Blocknode",
2168 onSelect: function() {
22f87669 2169 network = libs.bitcoin.networks.blocknode;
6f435817
U		 2170 setHdCoin(2941);
2171 },
d0889ab9 2172 },
96ee8ab0 2173 {
6f435817
U		 2174 name: "tBND - Blocknode Testnet",
2175 onSelect: function() {
22f87669 2176 network = libs.bitcoin.networks.blocknode_testnet;
6f435817
U		 2177 setHdCoin(1);
2178 },
2179 },
85f762c9 2180 {
2181 name: "BRIT - Britcoin",
85f762c9 2182 onSelect: function() {
22f87669 2183 network = libs.bitcoin.networks.britcoin;
85f762c9 2184 setHdCoin(70);
2185 },
2186 },
2187 {
2188 name: "BSD - Bitsend",
85f762c9 2189 onSelect: function() {
22f87669 2190 network = libs.bitcoin.networks.bitsend;
85f762c9 2191 setHdCoin(91);
2192 },
f22f7677 2193 },
96ee8ab0 2194 {
f22f7677
PC		 2195 name: "BST - BlockStamp",
2196 onSelect: function() {
22f87669 2197 network = libs.bitcoin.networks.blockstamp;
f22f7677
PC		 2198 setHdCoin(254);
2199 },
85f762c9 2200 },
2201 {
2202 name: "BTA - Bata",
85f762c9 2203 onSelect: function() {
22f87669 2204 network = libs.bitcoin.networks.bata;
85f762c9 2205 setHdCoin(89);
2206 },
2207 },
7f15cb6e 2208 {
534481b6 2209 name: "BTC - Bitcoin",
7a995731 2210 onSelect: function() {
22f87669 2211 network = libs.bitcoin.networks.bitcoin;
6c08f364 2212 setHdCoin(0);
7a995731
IC		 2213 },
2214 },
f1224201
IC		 2215 {
2216 name: "BTC - Bitcoin RegTest",
2217 onSelect: function() {
22f87669 2218 network = libs.bitcoin.networks.regtest;
f1224201
IC		 2219 // Using hd coin value 1 based on bip44_coin_type
2220 // https://github.com/chaintope/bitcoinrb/blob/f1014406f6b8f9b4edcecedc18df70c80df06f11/lib/bitcoin/chainparams/regtest.yml
2221 setHdCoin(1);
2222 },
2223 },
7f15cb6e 2224 {
534481b6 2225 name: "BTC - Bitcoin Testnet",
7a995731 2226 onSelect: function() {
22f87669 2227 network = libs.bitcoin.networks.testnet;
6c08f364 2228 setHdCoin(1);
7a995731 2229 },
8b2a093c 2230 },
96ee8ab0 2231 {
8b2a093c
PC		 2232 name: "BITG - Bitcoin Green",
2233 onSelect: function() {
22f87669 2234 network = libs.bitcoin.networks.bitcoingreen;
8b2a093c
PC		 2235 setHdCoin(222);
2236 },
7a995731 2237 },
1e2cc748 2238 {
2239 name: "BTCP - Bitcoin Private",
1e2cc748 2240 onSelect: function() {
22f87669 2241 network = libs.bitcoin.networks.bitcoinprivate;
1e2cc748 2242 setHdCoin(183);
2243 },
2244 },
31264e8b
PT		 2245 {
2246 name: "BSV - BitcoinSV",
2247 onSelect: function() {
22f87669 2248 network = libs.bitcoin.networks.bitcoinsv;
31264e8b
PT		 2249 setHdCoin(236);
2250 },
2251 },
1e2cc748 2252 {
2253 name: "BTCZ - Bitcoinz",
1e2cc748 2254 onSelect: function() {
22f87669 2255 network = libs.bitcoin.networks.bitcoinz;
1e2cc748 2256 setHdCoin(177);
2257 },
2258 },
5ed5f661
D		 2259 {
2260 name: "BTDX - BitCloud",
2261 onSelect: function() {
22f87669 2262 network = libs.bitcoin.networks.bitcloud;
5ed5f661
D		 2263 setHdCoin(218);
2264 },
2265 },
39608073
RS		 2266 {
2267 name: "BTG - Bitcoin Gold",
39608073 2268 onSelect: function() {
22f87669 2269 network = libs.bitcoin.networks.bgold;
88ae1301 2270 setHdCoin(156);
39608073
RS		 2271 },
2272 },
85f762c9 2273 {
2274 name: "BTX - Bitcore",
85f762c9 2275 onSelect: function() {
22f87669 2276 network = libs.bitcoin.networks.bitcore;
85f762c9 2277 setHdCoin(160);
2278 },
2279 },
2280 {
2281 name: "CCN - Cannacoin",
85f762c9 2282 onSelect: function() {
22f87669 2283 network = libs.bitcoin.networks.cannacoin;
85f762c9 2284 setHdCoin(19);
2285 },
2286 },
04ec88af
VD		 2287 {
2288 name: "CESC - Cryptoescudo",
2289 onSelect: function() {
22f87669 2290 network = libs.bitcoin.networks.cannacoin;
04ec88af
VD		 2291 setHdCoin(111);
2292 },
2293 },
85f762c9 2294 {
2295 name: "CDN - Canadaecoin",
85f762c9 2296 onSelect: function() {
22f87669 2297 network = libs.bitcoin.networks.canadaecoin;
85f762c9 2298 setHdCoin(34);
2299 },
2300 },
7f15cb6e 2301 {
534481b6 2302 name: "CLAM - Clams",
7a995731 2303 onSelect: function() {
22f87669 2304 network = libs.bitcoin.networks.clam;
6c08f364 2305 setHdCoin(23);
7a995731
IC		 2306 },
2307 },
bb381a72 2308 {
2309 name: "CLO - Callisto",
2310 segwitAvailable: false,
2311 onSelect: function() {
22f87669 2312 network = libs.bitcoin.networks.bitcoin;
bb381a72 2313 setHdCoin(820);
2314 },
2315 },
85f762c9 2316 {
2317 name: "CLUB - Clubcoin",
85f762c9 2318 onSelect: function() {
22f87669 2319 network = libs.bitcoin.networks.clubcoin;
85f762c9 2320 setHdCoin(79);
2321 },
2322 },
2323 {
2324 name: "CMP - Compcoin",
85f762c9 2325 onSelect: function() {
22f87669 2326 network = libs.bitcoin.networks.compcoin;
85f762c9 2327 setHdCoin(71);
2328 },
2329 },
519e9dc7
MKA		 2330 {
2331 name: "CPU - CPUchain",
2332 onSelect: function() {
22f87669 2333 network = libs.bitcoin.networks.cpuchain;
519e9dc7
MKA		 2334 setHdCoin(363);
2335 },
2336 },
85f762c9 2337 {
2338 name: "CRAVE - Crave",
85f762c9 2339 onSelect: function() {
22f87669 2340 network = libs.bitcoin.networks.crave;
85f762c9 2341 setHdCoin(186);
2342 },
2343 },
115eb450 2344 {
2345 name: "CRP - CranePay",
2346 onSelect: function() {
2347 network = libs.bitcoin.networks.cranepay;
2348 setHdCoin(2304);
2349 },
2350 },
2351
bf13c95f
PC		 2352 {
2353 name: "CRW - Crown (Legacy)",
2354 onSelect: function() {
22f87669 2355 network = libs.bitcoin.networks.crown;
bf13c95f
PC		 2356 setHdCoin(72);
2357 },
2358 },
0921f370 2359 {
2360 name: "CRW - Crown",
2361 onSelect: function() {
22f87669 2362 network = libs.bitcoin.networks.crown;
6c08f364 2363 setHdCoin(72);
0921f370 2364 },
2365 },
45e40c28
C		 2366 {
2367 name: "CSC - CasinoCoin",
2368 onSelect: function() {
22f87669 2369 network = libs.bitcoin.networks.bitcoin;
45e40c28
C		 2370 setHdCoin(359);
2371 },
2372 },
7f15cb6e 2373 {
534481b6 2374 name: "DASH - Dash",
e3a9508c 2375 onSelect: function() {
22f87669 2376 network = libs.bitcoin.networks.dash;
6c08f364 2377 setHdCoin(5);
e3a9508c
IC		 2378 },
2379 },
c0386f3b 2380 {
534481b6 2381 name: "DASH - Dash Testnet",
c0386f3b 2382 onSelect: function() {
22f87669 2383 network = libs.bitcoin.networks.dashtn;
6c08f364 2384 setHdCoin(1);
c0386f3b
KR		 2385 },
2386 },
85f762c9 2387 {
2388 name: "DFC - Defcoin",
85f762c9 2389 onSelect: function() {
22f87669 2390 network = libs.bitcoin.networks.defcoin;
85f762c9 2391 setHdCoin(1337);
2392 },
2393 },
2394 {
2395 name: "DGB - Digibyte",
85f762c9 2396 onSelect: function() {
22f87669 2397 network = libs.bitcoin.networks.digibyte;
85f762c9 2398 setHdCoin(20);
2399 },
2400 },
2401 {
2402 name: "DGC - Digitalcoin",
85f762c9 2403 onSelect: function() {
22f87669 2404 network = libs.bitcoin.networks.digitalcoin;
85f762c9 2405 setHdCoin(18);
2406 },
2407 },
2408 {
2409 name: "DMD - Diamond",
85f762c9 2410 onSelect: function() {
22f87669 2411 network = libs.bitcoin.networks.diamond;
85f762c9 2412 setHdCoin(152);
2413 },
2414 },
40209fd8 2415 {
2416 name: "DNR - Denarius",
40209fd8 2417 onSelect: function() {
22f87669 2418 network = libs.bitcoin.networks.denarius;
50289881 2419 setHdCoin(116);
40209fd8 2420 },
2421 },
e3a9508c 2422 {
534481b6 2423 name: "DOGE - Dogecoin",
2424 onSelect: function() {
22f87669 2425 network = libs.bitcoin.networks.dogecoin;
6c08f364 2426 setHdCoin(3);
534481b6 2427 },
2428 },
b85da074
PD		 2429 {
2430 name: "DOGEt - Dogecoin Testnet",
2431 onSelect: function() {
22f87669 2432 network = libs.bitcoin.networks.dogecointestnet;
b85da074
PD		 2433 setHdCoin(1);
2434 },
2435 },
6cbd3bc8
HL		 2436 {
2437 name: "DXN - DEXON",
2438 onSelect: function() {
22f87669 2439 network = libs.bitcoin.networks.bitcoin;
6cbd3bc8
HL		 2440 setHdCoin(237);
2441 },
2442 },
85f762c9 2443 {
2444 name: "ECN - Ecoin",
85f762c9 2445 onSelect: function() {
22f87669 2446 network = libs.bitcoin.networks.ecoin;
85f762c9 2447 setHdCoin(115);
2448 },
2449 },
2450 {
2451 name: "EDRC - Edrcoin",
85f762c9 2452 onSelect: function() {
22f87669 2453 network = libs.bitcoin.networks.edrcoin;
85f762c9 2454 setHdCoin(56);
2455 },
2456 },
2457 {
2458 name: "EFL - Egulden",
85f762c9 2459 onSelect: function() {
22f87669 2460 network = libs.bitcoin.networks.egulden;
85f762c9 2461 setHdCoin(78);
2462 },
2885ddd5 2463 },
36523e0d
NJ		 2464 {
2465 name: "ELA - Elastos",
2466 onSelect: function () {
22f87669 2467 network = libs.bitcoin.networks.elastos;
36523e0d
NJ		 2468 setHdCoin(2305);
2469 },
2470 },
2885ddd5 2471 {
2472 name: "ELLA - Ellaism",
2473 segwitAvailable: false,
2474 onSelect: function() {
22f87669 2475 network = libs.bitcoin.networks.bitcoin;
2885ddd5 2476 setHdCoin(163);
2477 },
85f762c9 2478 },
2479 {
2480 name: "EMC2 - Einsteinium",
85f762c9 2481 onSelect: function() {
22f87669 2482 network = libs.bitcoin.networks.einsteinium;
85f762c9 2483 setHdCoin(41);
2484 },
2485 },
2486 {
2487 name: "ERC - Europecoin",
85f762c9 2488 onSelect: function() {
22f87669 2489 network = libs.bitcoin.networks.europecoin;
85f762c9 2490 setHdCoin(151);
2491 },
2492 },
3451d1a8
JU		 2493 {
2494 name: "EOS - EOSIO",
2495 onSelect: function() {
22f87669 2496 network = libs.bitcoin.networks.bitcoin;
3451d1a8
JU		 2497 setHdCoin(194);
2498 },
2499 },
8131a071
EC		 2500 {
2501 name: "ERE - EtherCore",
2502 segwitAvailable: false,
2503 onSelect: function() {
2504 network = libs.bitcoin.networks.bitcoin;
2505 setHdCoin(466);
2506 },
2507 },
16afe3ec 2508 {
2509 name: "ESN - Ethersocial Network",
2510 segwitAvailable: false,
2511 onSelect: function() {
22f87669 2512 network = libs.bitcoin.networks.bitcoin;
16afe3ec 2513 setHdCoin(31102);
2514 },
2515 },
bb381a72 2516 {
2517 name: "ETC - Ethereum Classic",
2518 segwitAvailable: false,
2519 onSelect: function() {
22f87669 2520 network = libs.bitcoin.networks.bitcoin;
bb381a72 2521 setHdCoin(61);
2522 },
2523 },
534481b6 2524 {
2525 name: "ETH - Ethereum",
e3a9508c 2526 onSelect: function() {
22f87669 2527 network = libs.bitcoin.networks.bitcoin;
6c08f364 2528 setHdCoin(60);
e3a9508c 2529 },
dd99c5fd
GM		 2530 },
2531 {
2532 name: "EWT - EnergyWeb",
2533 onSelect: function() {
22f87669 2534 network = libs.bitcoin.networks.bitcoin;
dd99c5fd
GM		 2535 setHdCoin(246);
2536 },
2537 },
85f762c9 2538 {
2539 name: "EXCL - Exclusivecoin",
85f762c9 2540 onSelect: function() {
22f87669 2541 network = libs.bitcoin.networks.exclusivecoin;
85f762c9 2542 setHdCoin(190);
2543 },
2544 },
a44c45e3 2545 {
2546 name: "EXCC - ExchangeCoin",
2547 onSelect: function() {
22f87669 2548 network = libs.bitcoin.networks.exchangecoin;
a44c45e3 2549 setHdCoin(0);
2550 },
2551 },
bb381a72 2552 {
2553 name: "EXP - Expanse",
2554 segwitAvailable: false,
2555 onSelect: function() {
22f87669 2556 network = libs.bitcoin.networks.bitcoin;
bb381a72 2557 setHdCoin(40);
2558 },
2559 },
d1d8699f
SA		 2560 {
2561 name: "FIO - Foundation for Interwallet Operability",
2562 onSelect: function() {
2563 network = libs.bitcoin.networks.bitcoin;
2564 setHdCoin(235);
2565 },
2566 },
7d4e4cbe 2567 {
2568 name: "FIX - FIX",
2569 onSelect: function() {
22f87669 2570 network = libs.bitcoin.networks.fix;
7d4e4cbe 2571 setHdCoin(336);
2572 },
2573 },
2574 {
2575 name: "FIX - FIX Testnet",
2576 onSelect: function() {
22f87669 2577 network = libs.bitcoin.networks.fixtestnet;
7d4e4cbe 2578 setHdCoin(1);
2579 },
2580 },
6e679905 2581 {
2582 name: "FJC - Fujicoin",
6e679905 2583 onSelect: function() {
22f87669 2584 network = libs.bitcoin.networks.fujicoin;
6e679905 2585 setHdCoin(75);
2586 },
2587 },
85f762c9 2588 {
2589 name: "FLASH - Flashcoin",
85f762c9 2590 onSelect: function() {
22f87669 2591 network = libs.bitcoin.networks.flashcoin;
85f762c9 2592 setHdCoin(120);
2593 },
2594 },
2595 {
2596 name: "FRST - Firstcoin",
85f762c9 2597 onSelect: function() {
22f87669 2598 network = libs.bitcoin.networks.firstcoin;
85f762c9 2599 setHdCoin(167);
2600 },
2601 },
2602 {
2603 name: "FTC - Feathercoin",
85f762c9 2604 onSelect: function() {
22f87669 2605 network = libs.bitcoin.networks.feathercoin;
85f762c9 2606 setHdCoin(8);
2607 },
2608 },
f88fab20 2609 {
534481b6 2610 name: "GAME - GameCredits",
f88fab20 2611 onSelect: function() {
22f87669 2612 network = libs.bitcoin.networks.game;
6c08f364 2613 setHdCoin(101);
f88fab20 2614 },
2615 },
85f762c9 2616 {
2617 name: "GBX - Gobyte",
85f762c9 2618 onSelect: function() {
22f87669 2619 network = libs.bitcoin.networks.gobyte;
85f762c9 2620 setHdCoin(176);
2621 },
2622 },
2623 {
2624 name: "GCR - GCRCoin",
85f762c9 2625 onSelect: function() {
22f87669 2626 network = libs.bitcoin.networks.gcr;
85f762c9 2627 setHdCoin(79);
2628 },
2629 },
2630 {
2631 name: "GRC - Gridcoin",
85f762c9 2632 onSelect: function() {
22f87669 2633 network = libs.bitcoin.networks.gridcoin;
85f762c9 2634 setHdCoin(84);
2635 },
76120cb0
H		 2636 },
2637 {
2638 name: "GRS - Groestlcoin",
2639 onSelect: function() {
22f87669 2640 network = libs.bitcoin.networks.groestlcoin;
76120cb0
H		 2641 setHdCoin(17);
2642 },
2643 },
2644 {
2645 name: "GRS - Groestlcoin Testnet",
2646 onSelect: function() {
22f87669 2647 network = libs.bitcoin.networks.groestlcointestnet;
76120cb0
H		 2648 setHdCoin(1);
2649 },
85f762c9 2650 },
0e1fd953
JK		 2651 {
2652 name: "HNS - Handshake",
2653 onSelect: function() {
2654 setHdCoin(5353);
2655 },
2656 },
85f762c9 2657 {
2658 name: "HNC - Helleniccoin",
85f762c9 2659 onSelect: function() {
22f87669 2660 network = libs.bitcoin.networks.helleniccoin;
85f762c9 2661 setHdCoin(168);
2662 },
60727c51 2663 },
96ee8ab0 2664 {
318ec4dc 2665 name: "HUSH - Hush (Legacy)",
60727c51 2666 onSelect: function() {
22f87669 2667 network = libs.bitcoin.networks.hush;
60727c51
PC		 2668 setHdCoin(197);
2669 },
85f762c9 2670 },
96ee8ab0 2671 {
318ec4dc
PC		 2672 name: "HUSH - Hush3",
2673 onSelect: function() {
22f87669 2674 network = libs.bitcoin.networks.hush3;
318ec4dc
PC		 2675 setHdCoin(197);
2676 },
2677 },
85f762c9 2678 {
2679 name: "INSN - Insane",
85f762c9 2680 onSelect: function() {
22f87669 2681 network = libs.bitcoin.networks.insane;
85f762c9 2682 setHdCoin(68);
2683 },
2684 },
2685 {
2686 name: "IOP - Iop",
85f762c9 2687 onSelect: function() {
22f87669 2688 network = libs.bitcoin.networks.iop;
85f762c9 2689 setHdCoin(66);
2690 },
2691 },
2692 {
2693 name: "IXC - Ixcoin",
85f762c9 2694 onSelect: function() {
22f87669 2695 network = libs.bitcoin.networks.ixcoin;
85f762c9 2696 setHdCoin(86);
2697 },
2698 },
a3baa26e 2699 {
534481b6 2700 name: "JBS - Jumbucks",
a3baa26e 2701 onSelect: function() {
22f87669 2702 network = libs.bitcoin.networks.jumbucks;
6c08f364 2703 setHdCoin(26);
a3baa26e
IC		 2704 },
2705 },
aab3645f 2706 {
2707 name: "KMD - Komodo",
2708 bip49available: false,
2709 onSelect: function() {
22f87669 2710 network = libs.bitcoin.networks.komodo;
aab3645f 2711 setHdCoin(141);
2712 },
2713 },
0a5d28a7 2714 {
2715 name: "KOBO - Kobocoin",
2716 bip49available: false,
2717 onSelect: function() {
22f87669 2718 network = libs.bitcoin.networks.kobocoin;
0a5d28a7 2719 setHdCoin(196);
2720 },
2721 },
85f762c9 2722 {
2723 name: "LBC - Library Credits",
85f762c9 2724 onSelect: function() {
22f87669 2725 network = libs.bitcoin.networks.lbry;
85f762c9 2726 setHdCoin(140);
2727 },
2728 },
2729 {
2730 name: "LCC - Litecoincash",
85f762c9 2731 onSelect: function() {
22f87669 2732 network = libs.bitcoin.networks.litecoincash;
85f762c9 2733 setHdCoin(192);
2734 },
2735 },
2736 {
2737 name: "LDCN - Landcoin",
85f762c9 2738 onSelect: function() {
22f87669 2739 network = libs.bitcoin.networks.landcoin;
85f762c9 2740 setHdCoin(63);
2741 },
2742 },
2743 {
2744 name: "LINX - Linx",
85f762c9 2745 onSelect: function() {
22f87669 2746 network = libs.bitcoin.networks.linx;
85f762c9 2747 setHdCoin(114);
2748 },
2749 },
8ba31a89
JLEP		 2750 {
2751 name: "LKR - Lkrcoin",
2752 segwitAvailable: false,
2753 onSelect: function() {
22f87669 2754 network = libs.bitcoin.networks.lkrcoin;
8ba31a89
JLEP		 2755 setHdCoin(557);
2756 },
2757 },
a3baa26e 2758 {
534481b6 2759 name: "LTC - Litecoin",
a3baa26e 2760 onSelect: function() {
22f87669 2761 network = libs.bitcoin.networks.litecoin;
6c08f364 2762 setHdCoin(2);
3abab9b0 2763 DOM.litecoinLtubContainer.removeClass("hidden");
a3baa26e
IC		 2764 },
2765 },
b85da074
PD		 2766 {
2767 name: "LTCt - Litecoin Testnet",
2768 onSelect: function() {
22f87669 2769 network = libs.bitcoin.networks.litecointestnet;
b85da074
PD		 2770 setHdCoin(1);
2771 DOM.litecoinLtubContainer.removeClass("hidden");
2772 },
2773 },
d4fcdda9
PC		 2774 {
2775 name: "LTZ - LitecoinZ",
2776 onSelect: function() {
22f87669 2777 network = libs.bitcoin.networks.litecoinz;
d4fcdda9
PC		 2778 setHdCoin(221);
2779 },
2780 },
85f762c9 2781 {
2782 name: "LYNX - Lynx",
85f762c9 2783 onSelect: function() {
22f87669 2784 network = libs.bitcoin.networks.lynx;
85f762c9 2785 setHdCoin(191);
2786 },
2787 },
56ad9601
JS		 2788 {
2789 name: "MAZA - Maza",
56ad9601 2790 onSelect: function() {
22f87669 2791 network = libs.bitcoin.networks.maza;
56ad9601
JS		 2792 setHdCoin(13);
2793 },
2794 },
5ed5f661
D		 2795 {
2796 name: "MEC - Megacoin",
2797 onSelect: function() {
22f87669 2798 network = libs.bitcoin.networks.megacoin;
5ed5f661
D		 2799 setHdCoin(217);
2800 },
2801 },
bb381a72 2802 {
2803 name: "MIX - MIX",
2804 segwitAvailable: false,
2805 onSelect: function() {
22f87669 2806 network = libs.bitcoin.networks.bitcoin;
bb381a72 2807 setHdCoin(76);
2808 },
2809 },
85f762c9 2810 {
2811 name: "MNX - Minexcoin",
85f762c9 2812 onSelect: function() {
22f87669 2813 network = libs.bitcoin.networks.minexcoin;
85f762c9 2814 setHdCoin(182);
2815 },
2816 },
f487fea9
IC		 2817 {
2818 name: "MONA - Monacoin",
f487fea9 2819 onSelect: function() {
22f87669 2820 network = libs.bitcoin.networks.monacoin,
f487fea9
IC		 2821 setHdCoin(22);
2822 },
2823 },
31264e8b
PT		 2824 {
2825 name: "MONK - Monkey Project",
2826 onSelect: function() {
22f87669 2827 network = libs.bitcoin.networks.monkeyproject,
31264e8b
PT		 2828 setHdCoin(214);
2829 },
2830 },
46a5338e
LL		 2831 {
2832 name: "MOAC - MOAC",
2833 segwitAvailable: false,
2834 onSelect: function() {
2835 network = libs.bitcoin.networks.bitcoin;
2836 setHdCoin(314);
2837 },
2838 },
bb381a72 2839 {
2840 name: "MUSIC - Musicoin",
2841 segwitAvailable: false,
2842 onSelect: function() {
22f87669 2843 network = libs.bitcoin.networks.bitcoin;
bb381a72 2844 setHdCoin(184);
2845 },
2846 },
85f762c9 2847 {
2848 name: "NAV - Navcoin",
85f762c9 2849 onSelect: function() {
22f87669 2850 network = libs.bitcoin.networks.navcoin;
85f762c9 2851 setHdCoin(130);
2852 },
2853 },
7a113003 2854 {
2855 name: "NAS - Nebulas",
2856 onSelect: function() {
22f87669 2857 network = libs.bitcoin.networks.bitcoin;
7a113003 2858 setHdCoin(2718);
2859 },
2860 },
db37d639
IC		 2861 {
2862 name: "NEBL - Neblio",
db37d639 2863 onSelect: function() {
22f87669 2864 network = libs.bitcoin.networks.neblio;
db37d639
IC		 2865 setHdCoin(146);
2866 },
2867 },
85f762c9 2868 {
2869 name: "NEOS - Neoscoin",
85f762c9 2870 onSelect: function() {
22f87669 2871 network = libs.bitcoin.networks.neoscoin;
85f762c9 2872 setHdCoin(25);
2873 },
2874 },
10980ed6 2875 {
2876 name: "NIX - NIX Platform",
2877 onSelect: function() {
22f87669 2878 network = libs.bitcoin.networks.nix;
10980ed6 2879 setHdCoin(400);
2880 },
2881 },
85f762c9 2882 {
2883 name: "NLG - Gulden",
85f762c9 2884 onSelect: function() {
22f87669 2885 network = libs.bitcoin.networks.gulden;
85f762c9 2886 setHdCoin(87);
2887 },
2888 },
a3baa26e 2889 {
534481b6 2890 name: "NMC - Namecoin",
a3baa26e 2891 onSelect: function() {
22f87669 2892 network = libs.bitcoin.networks.namecoin;
6c08f364 2893 setHdCoin(7);
a3baa26e
IC		 2894 },
2895 },
1e2cc748 2896 {
2897 name: "NRG - Energi",
1e2cc748 2898 onSelect: function() {
22f87669 2899 network = libs.bitcoin.networks.energi;
1e2cc748 2900 setHdCoin(204);
2901 },
2902 },
85f762c9 2903 {
2904 name: "NRO - Neurocoin",
85f762c9 2905 onSelect: function() {
22f87669 2906 network = libs.bitcoin.networks.neurocoin;
85f762c9 2907 setHdCoin(110);
2908 },
2909 },
2910 {
2911 name: "NSR - Nushares",
85f762c9 2912 onSelect: function() {
22f87669 2913 network = libs.bitcoin.networks.nushares;
85f762c9 2914 setHdCoin(11);
2915 },
2916 },
2917 {
2918 name: "NYC - Newyorkc",
85f762c9 2919 onSelect: function() {
22f87669 2920 network = libs.bitcoin.networks.newyorkc;
85f762c9 2921 setHdCoin(179);
2922 },
2923 },
2924 {
2925 name: "NVC - Novacoin",
85f762c9 2926 onSelect: function() {
22f87669 2927 network = libs.bitcoin.networks.novacoin;
85f762c9 2928 setHdCoin(50);
2929 },
2930 },
2931 {
2932 name: "OK - Okcash",
85f762c9 2933 onSelect: function() {
22f87669 2934 network = libs.bitcoin.networks.okcash;
85f762c9 2935 setHdCoin(69);
2936 },
2937 },
2938 {
2939 name: "OMNI - Omnicore",
85f762c9 2940 onSelect: function() {
22f87669 2941 network = libs.bitcoin.networks.omnicore;
85f762c9 2942 setHdCoin(200);
2943 },
2944 },
af14981d
A		 2945 {
2946 name: "ONION - DeepOnion",
2947 onSelect: function() {
22f87669 2948 network = libs.bitcoin.networks.deeponion;
af14981d
A		 2949 setHdCoin(305);
2950 },
2951 },
66419cf3 2952 {
2953 name: "ONX - Onixcoin",
66419cf3 2954 onSelect: function() {
22f87669 2955 network = libs.bitcoin.networks.onixcoin;
d00c7199 2956 setHdCoin(174);
66419cf3 2957 },
38d1b296 2958 },
96ee8ab0 2959 {
38d1b296
PC		 2960 name: "PHR - Phore",
2961 onSelect: function() {
22f87669 2962 network = libs.bitcoin.networks.phore;
38d1b296
PC		 2963 setHdCoin(444);
2964 },
66419cf3 2965 },
85f762c9 2966 {
2967 name: "PINK - Pinkcoin",
85f762c9 2968 onSelect: function() {
22f87669 2969 network = libs.bitcoin.networks.pinkcoin;
85f762c9 2970 setHdCoin(117);
2971 },
2972 },
bb381a72 2973 {
2974 name: "PIRL - Pirl",
2975 segwitAvailable: false,
2976 onSelect: function() {
22f87669 2977 network = libs.bitcoin.networks.bitcoin;
bb381a72 2978 setHdCoin(164);
2979 },
2980 },
c0df0189 2981 {
2982 name: "PIVX - PIVX",
c0df0189 2983 onSelect: function() {
22f87669 2984 network = libs.bitcoin.networks.pivx;
c0df0189 2985 setHdCoin(119);
2986 },
2987 },
2988 {
2989 name: "PIVX - PIVX Testnet",
c0df0189 2990 onSelect: function() {
22f87669 2991 network = libs.bitcoin.networks.pivxtestnet;
c0df0189 2992 setHdCoin(1);
2993 },
2994 },
bb381a72 2995 {
2996 name: "POA - Poa",
2997 segwitAvailable: false,
2998 onSelect: function() {
22f87669 2999 network = libs.bitcoin.networks.bitcoin;
bb381a72 3000 setHdCoin(178);
3001 },
3002 },
85f762c9 3003 {
3004 name: "POSW - POSWcoin",
85f762c9 3005 onSelect: function() {
22f87669 3006 network = libs.bitcoin.networks.poswcoin;
85f762c9 3007 setHdCoin(47);
3008 },
3009 },
3010 {
3011 name: "POT - Potcoin",
85f762c9 3012 onSelect: function() {
22f87669 3013 network = libs.bitcoin.networks.potcoin;
85f762c9 3014 setHdCoin(81);
3015 },
3016 },
5c434a8a 3017 {
534481b6 3018 name: "PPC - Peercoin",
5c434a8a 3019 onSelect: function() {
22f87669 3020 network = libs.bitcoin.networks.peercoin;
6c08f364 3021 setHdCoin(6);
5c434a8a 3022 },
d2ba3871 3023 },
96ee8ab0 3024 {
d2ba3871
PC		 3025 name: "PRJ - ProjectCoin",
3026 onSelect: function() {
22f87669 3027 network = libs.bitcoin.networks.projectcoin;
d2ba3871
PC		 3028 setHdCoin(533);
3029 },
5c434a8a 3030 },
85f762c9 3031 {
3032 name: "PSB - Pesobit",
85f762c9 3033 onSelect: function() {
22f87669 3034 network = libs.bitcoin.networks.pesobit;
85f762c9 3035 setHdCoin(62);
3036 },
3037 },
3038 {
3039 name: "PUT - Putincoin",
85f762c9 3040 onSelect: function() {
22f87669 3041 network = libs.bitcoin.networks.putincoin;
85f762c9 3042 setHdCoin(122);
3043 },
3044 },
31264e8b
PT		 3045 {
3046 name: "RPD - Rapids",
3047 onSelect: function() {
22f87669 3048 network = libs.bitcoin.networks.rapids;
31264e8b
PT		 3049 setHdCoin(320);
3050 },
3051 },
1fe8f519 3052 {
3053 name: "RVN - Ravencoin",
3054 onSelect: function() {
22f87669 3055 network = libs.bitcoin.networks.ravencoin;
1fe8f519 3056 setHdCoin(175);
3057 },
3058 },
e9491c7e 3059 {
b64fb353 3060 name: "R-BTC - RSK",
e9491c7e 3061 onSelect: function() {
b64fb353 3062 network = libs.bitcoin.networks.rsk;
e9491c7e
I		 3063 setHdCoin(137);
3064 },
3065 },
3066 {
b64fb353 3067 name: "tR-BTC - RSK Testnet",
e9491c7e 3068 onSelect: function() {
b64fb353 3069 network = libs.bitcoin.networks.rsktestnet;
e9491c7e
I		 3070 setHdCoin(37310);
3071 },
3072 },
85f762c9 3073 {
3074 name: "RBY - Rubycoin",
85f762c9 3075 onSelect: function() {
22f87669 3076 network = libs.bitcoin.networks.rubycoin;
85f762c9 3077 setHdCoin(16);
3078 },
3079 },
3080 {
3081 name: "RDD - Reddcoin",
85f762c9 3082 onSelect: function() {
22f87669 3083 network = libs.bitcoin.networks.reddcoin;
85f762c9 3084 setHdCoin(4);
3085 },
3086 },
3087 {
3088 name: "RVR - RevolutionVR",
85f762c9 3089 onSelect: function() {
22f87669 3090 network = libs.bitcoin.networks.revolutionvr;
85f762c9 3091 setHdCoin(129);
3092 },
3093 },
7878bb32 3094 {
d645b982
E		 3095 name: "SAFE - Safecoin",
3096 onSelect: function() {
22f87669 3097 network = libs.bitcoin.networks.safecoin;
d645b982
E		 3098 setHdCoin(19165);
3099 },
3100 },
fba7e98a 3101 {
3102 name: "SCRIBE - Scribe",
3103 onSelect: function() {
3104 network = libs.bitcoin.networks.scribe;
3105 setHdCoin(545);
3106 },
3107 },
96ee8ab0 3108 {
7878bb32
S		 3109 name: "SLS - Salus",
3110 onSelect: function() {
22f87669 3111 network = libs.bitcoin.networks.salus;
7878bb32
S		 3112 setHdCoin(63);
3113 },
3114 },
64a7d2aa 3115 {
534481b6 3116 name: "SDC - ShadowCash",
82f91834 3117 onSelect: function() {
22f87669 3118 network = libs.bitcoin.networks.shadow;
6c08f364 3119 setHdCoin(35);
82f91834
DG		 3120 },
3121 },
07ac4350 3122 {
534481b6 3123 name: "SDC - ShadowCash Testnet",
07ac4350 3124 onSelect: function() {
22f87669 3125 network = libs.bitcoin.networks.shadowtn;
6c08f364 3126 setHdCoin(1);
07ac4350 3127 },
3128 },
7a5a87a0 3129 {
534481b6 3130 name: "SLM - Slimcoin",
7a5a87a0 3131 onSelect: function() {
22f87669 3132 network = libs.bitcoin.networks.slimcoin;
6c08f364 3133 setHdCoin(63);
7a5a87a0
GH		 3134 },
3135 },
3136 {
534481b6 3137 name: "SLM - Slimcoin Testnet",
7a5a87a0 3138 onSelect: function() {
22f87669 3139 network = libs.bitcoin.networks.slimcointn;
6c08f364 3140 setHdCoin(111);
7a5a87a0
GH		 3141 },
3142 },
d0889ab9 3143 {
3144 name: "SLP - Simple Ledger Protocol",
3145 onSelect: function() {
3146 DOM.bitcoinCashAddressTypeContainer.removeClass("hidden");
3147 setHdCoin(245);
3148 },
3149 },
85f762c9 3150 {
3151 name: "SLR - Solarcoin",
85f762c9 3152 onSelect: function() {
22f87669 3153 network = libs.bitcoin.networks.solarcoin;
85f762c9 3154 setHdCoin(58);
3155 },
3156 },
3157 {
3158 name: "SMLY - Smileycoin",
85f762c9 3159 onSelect: function() {
22f87669 3160 network = libs.bitcoin.networks.smileycoin;
85f762c9 3161 setHdCoin(59);
3162 },
3163 },
ae51db39
B		 3164 {
3165 name: "STASH - Stash",
3166 onSelect: function() {
22f87669 3167 network = libs.bitcoin.networks.stash;
ae51db39
B		 3168 setHdCoin(0xC0C0);
3169 },
3170 },
3171 {
3172 name: "STASH - Stash Testnet",
3173 onSelect: function() {
22f87669 3174 network = libs.bitcoin.networks.stashtn;
ae51db39
B		 3175 setHdCoin(0xCAFE);
3176 },
3177 },
85f762c9 3178 {
3179 name: "STRAT - Stratis",
85f762c9 3180 onSelect: function() {
22f87669 3181 network = libs.bitcoin.networks.stratis;
85f762c9 3182 setHdCoin(105);
3183 },
3184 },
4958ea80
JC		 3185 {
3186 name: "SUGAR - Sugarchain",
3187 onSelect: function() {
3188 network = libs.bitcoin.networks.sugarchain;
3189 setHdCoin(408);
3190 },
3191 },
75944050
JC		 3192 {
3193 name: "TUGAR - Sugarchain Testnet",
3194 onSelect: function() {
3195 network = libs.bitcoin.networks.sugarchaintestnet;
3196 setHdCoin(408);
3197 },
3198 },
46a5338e
LL		 3199 {
3200 name: "SWTC - Jingtum",
3201 onSelect: function() {
3202 network = libs.bitcoin.networks.bitcoin;
3203 setHdCoin(315);
3204 },
3205 },
3b43552c
AD		 3206 {
3207 name: "TSTRAT - Stratis Testnet",
3208 onSelect: function() {
22f87669 3209 network = libs.bitcoin.networks.stratistest;
3b43552c
AD		 3210 setHdCoin(105);
3211 },
3212 },
85f762c9 3213 {
3214 name: "SYS - Syscoin",
85f762c9 3215 onSelect: function() {
22f87669 3216 network = libs.bitcoin.networks.syscoin;
85f762c9 3217 setHdCoin(57);
3218 },
3219 },
3220 {
3221 name: "THC - Hempcoin",
85f762c9 3222 onSelect: function() {
22f87669 3223 network = libs.bitcoin.networks.hempcoin;
85f762c9 3224 setHdCoin(113);
3225 },
3226 },
75138bee
A		 3227 {
3228 name: "THT - Thought",
3229 onSelect: function() {
22f87669 3230 network = libs.bitcoin.networks.thought;
75138bee
A		 3231 setHdCoin(1618);
3232 },
3233 },
85f762c9 3234 {
3235 name: "TOA - Toa",
85f762c9 3236 onSelect: function() {
22f87669 3237 network = libs.bitcoin.networks.toa;
85f762c9 3238 setHdCoin(159);
3239 },
3240 },
b674c571 3241 {
3242 name: "TRX - Tron",
3243 onSelect: function() {
3244 setHdCoin(195);
3245 },
3246 },
82e3938a 3247 {
3248 name: "TWINS - TWINS",
3249 onSelect: function() {
22f87669 3250 network = libs.bitcoin.networks.twins;
82e3938a 3251 setHdCoin(970);
3252 },
3253 },
3254 {
3255 name: "TWINS - TWINS Testnet",
3256 onSelect: function() {
22f87669 3257 network = libs.bitcoin.networks.twinstestnet;
82e3938a 3258 setHdCoin(1);
3259 },
3260 },
85f762c9 3261 {
3262 name: "USC - Ultimatesecurecash",
85f762c9 3263 onSelect: function() {
22f87669 3264 network = libs.bitcoin.networks.ultimatesecurecash;
85f762c9 3265 setHdCoin(112);
3266 },
3267 },
8dd28f2c 3268 {
3269 name: "USNBT - NuBits",
8dd28f2c 3270 onSelect: function() {
22f87669 3271 network = libs.bitcoin.networks.nubits;
8dd28f2c 3272 setHdCoin(12);
3273 },
3274 },
85f762c9 3275 {
3276 name: "UNO - Unobtanium",
85f762c9 3277 onSelect: function() {
22f87669 3278 network = libs.bitcoin.networks.unobtanium;
85f762c9 3279 setHdCoin(92);
3280 },
3281 },
3282 {
3283 name: "VASH - Vpncoin",
85f762c9 3284 onSelect: function() {
22f87669 3285 network = libs.bitcoin.networks.vpncoin;
85f762c9 3286 setHdCoin(33);
3287 },
3288 },
c7a1a000
MR		 3289 {
3290 name: "VET - VeChain",
3291 onSelect: function() {
22f87669 3292 network = libs.bitcoin.networks.bitcoin;
c7a1a000
MR		 3293 setHdCoin(818);
3294 },
3295 },
07ac4350 3296 {
534481b6 3297 name: "VIA - Viacoin",
07ac4350 3298 onSelect: function() {
22f87669 3299 network = libs.bitcoin.networks.viacoin;
6c08f364 3300 setHdCoin(14);
07ac4350 3301 },
3302 },
0edac945 3303 {
534481b6 3304 name: "VIA - Viacoin Testnet",
0edac945 3305 onSelect: function() {
22f87669 3306 network = libs.bitcoin.networks.viacointestnet;
6c08f364 3307 setHdCoin(1);
0edac945
IC		 3308 },
3309 },
85f762c9 3310 {
3311 name: "VIVO - Vivo",
85f762c9 3312 onSelect: function() {
22f87669 3313 network = libs.bitcoin.networks.vivo;
85f762c9 3314 setHdCoin(166);
3315 },
3316 },
3317 {
3318 name: "VTC - Vertcoin",
85f762c9 3319 onSelect: function() {
22f87669 3320 network = libs.bitcoin.networks.vertcoin;
85f762c9 3321 setHdCoin(28);
3322 },
3323 },
67f18e2a
C		 3324 {
3325 name: "WGR - Wagerr",
3326 onSelect: function() {
22f87669 3327 network = libs.bitcoin.networks.wagerr;
67f18e2a
C		 3328 setHdCoin(7825266);
3329 },
3330 },
85f762c9 3331 {
3332 name: "WC - Wincoin",
85f762c9 3333 onSelect: function() {
22f87669 3334 network = libs.bitcoin.networks.wincoin;
85f762c9 3335 setHdCoin(181);
3336 },
2575538b 3337 },
96ee8ab0 3338 {
2575538b
PC		 3339 name: "XAX - Artax",
3340 onSelect: function() {
22f87669 3341 network = libs.bitcoin.networks.artax;
2575538b
PC		 3342 setHdCoin(219);
3343 },
85f762c9 3344 },
3345 {
3346 name: "XBC - Bitcoinplus",
85f762c9 3347 onSelect: function() {
22f87669 3348 network = libs.bitcoin.networks.bitcoinplus;
85f762c9 3349 setHdCoin(65);
3350 },
3351 },
612d6b42
SÖ		 3352 {
3353 name: "XLM - Stellar",
3354 onSelect: function() {
22f87669 3355 network = libs.stellarUtil.dummyNetwork;
612d6b42
SÖ		 3356 setHdCoin(148);
3357 },
3358 },
534481b6 3359 {
7ebdf61c 3360 name: "XMY - Myriadcoin",
534481b6 3361 onSelect: function() {
22f87669 3362 network = libs.bitcoin.networks.myriadcoin;
7ebdf61c 3363 setHdCoin(90);
534481b6 3364 },
adedbf91 3365 },
3366 {
7ebdf61c 3367 name: "XRP - Ripple",
adedbf91 3368 onSelect: function() {
22f87669 3369 network = libs.bitcoin.networks.bitcoin;
7ebdf61c 3370 setHdCoin(144);
adedbf91 3371 },
e1d0cf4f 3372 },
85f762c9 3373 {
3374 name: "XVC - Vcash",
85f762c9 3375 onSelect: function() {
22f87669 3376 network = libs.bitcoin.networks.vcash;
85f762c9 3377 setHdCoin(127);
3378 },
3379 },
3380 {
3381 name: "XVG - Verge",
85f762c9 3382 onSelect: function() {
22f87669 3383 network = libs.bitcoin.networks.verge;
85f762c9 3384 setHdCoin(77);
3385 },
3386 },
bb381a72 3387 {
3388 name: "XUEZ - Xuez",
3389 segwitAvailable: false,
3390 onSelect: function() {
22f87669 3391 network = libs.bitcoin.networks.xuez;
bb381a72 3392 setHdCoin(225);
3393 },
3394 },
85f762c9 3395 {
3396 name: "XWC - Whitecoin",
85f762c9 3397 onSelect: function() {
22f87669 3398 network = libs.bitcoin.networks.whitecoin;
85f762c9 3399 setHdCoin(155);
3400 },
3401 },
3402 {
3403 name: "XZC - Zcoin",
85f762c9 3404 onSelect: function() {
22f87669 3405 network = libs.bitcoin.networks.zcoin;
85f762c9 3406 setHdCoin(136);
3407 },
3408 },
1e2cc748 3409 {
3410 name: "ZCL - Zclassic",
1e2cc748 3411 onSelect: function() {
22f87669 3412 network = libs.bitcoin.networks.zclassic;
1e2cc748 3413 setHdCoin(147);
3414 },
3415 },
0702ecd3 3416 {
3417 name: "ZEC - Zcash",
0702ecd3 3418 onSelect: function() {
22f87669 3419 network = libs.bitcoin.networks.zcash;
0702ecd3 3420 setHdCoin(133);
3421 },
3422 },
1e2cc748 3423 {
9cec5dd2 3424 name: "ZEN - Horizen",
1e2cc748 3425 onSelect: function() {
22f87669 3426 network = libs.bitcoin.networks.zencash;
1e2cc748 3427 setHdCoin(121);
3428 },
3429 },
7f15cb6e 3430 ]
6ee4fb7d 3431
b4fd763c
AG		 3432 var clients = [
3433 {
3434 name: "Bitcoin Core",
3435 onSelect: function() {
3436 DOM.bip32path.val("m/0'/0'");
3437 DOM.hardenedAddresses.prop('checked', true);
3438 },
3439 },
3440 {
3441 name: "blockchain.info",
3442 onSelect: function() {
3443 DOM.bip32path.val("m/44'/0'/0'");
3444 DOM.hardenedAddresses.prop('checked', false);
3445 },
3446 },
3447 {
3448 name: "MultiBit HD",
3449 onSelect: function() {
3450 DOM.bip32path.val("m/0'/0");
3451 DOM.hardenedAddresses.prop('checked', false);
3452 },
bb381a72 3453 },
3454 {
3455 name: "Coinomi, Ledger",
3456 onSelect: function() {
3457 DOM.bip32path.val("m/44'/"+DOM.bip44coin.val()+"'/0'");
3458 DOM.hardenedAddresses.prop('checked', false);
3459 },
b4fd763c
AG		 3460 }
3461 ]
7a995731 3462
a823e526 3463 // RSK - RSK functions - begin
3464 function stripHexPrefix(address) {
3465 if (typeof address !== "string") {
3466 throw new Error("address parameter should be a string.");
3467 }
3468
3469 var hasPrefix = (address.substring(0, 2) === "0x" ||
3470 address.substring(0, 2) === "0X");
3471
3472 return hasPrefix ? address.slice(2) : address;
3473 };
3474
3475 function toChecksumAddressForRsk(address, chainId = null) {
3476 if (typeof address !== "string") {
3477 throw new Error("address parameter should be a string.");
3478 }
3479
3480 if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) {
3481 throw new Error("Given address is not a valid RSK address: " + address);
3482 }
3483
3484 var stripAddress = stripHexPrefix(address).toLowerCase();
3485 var prefix = chainId != null ? chainId.toString() + "0x" : "";
3486 var keccakHash = libs.ethUtil.keccak256(prefix + stripAddress)
3487 .toString("hex")
3488 .replace(/^0x/i, "");
3489 var checksumAddress = "0x";
3490
3491 for (var i = 0; i < stripAddress.length; i++) {
3492 checksumAddress +=
3493 parseInt(keccakHash[i], 16) >= 8 ?
3494 stripAddress[i].toUpperCase() :
3495 stripAddress[i];
3496 }
3497
3498 return checksumAddress;
3499 }
3500
3501 // RSK - RSK functions - end
3502
36523e0d
NJ		 3503 // ELA - Elastos functions - begin
3504 function displayBip44InfoForELA() {
3505 if (!isELA()) {
3506 return;
3507 }
3508
3509 var coin = parseIntNoNaN(DOM.bip44coin.val(), 0);
3510 var account = parseIntNoNaN(DOM.bip44account.val(), 0);
3511
3512 // Calculate the account extended keys
22f87669
IC		 3513 var accountXprv = libs.elastosjs.getAccountExtendedPrivateKey(seed, coin, account);
3514 var accountXpub = libs.elastosjs.getAccountExtendedPublicKey(seed, coin, account);
36523e0d
NJ		 3515
3516 // Display the extended keys
3517 DOM.bip44accountXprv.val(accountXprv);
3518 DOM.bip44accountXpub.val(accountXpub);
3519 }
3520
3521 function displayBip32InfoForELA() {
3522 if (!isELA()) {
3523 return;
3524 }
3525
3526 var coin = parseIntNoNaN(DOM.bip44coin.val(), 0);
3527 var account = parseIntNoNaN(DOM.bip44account.val(), 0);
3528 var change = parseIntNoNaN(DOM.bip44change.val(), 0);
3529
22f87669
IC		 3530 DOM.extendedPrivKey.val(libs.elastosjs.getBip32ExtendedPrivateKey(seed, coin, account, change));
3531 DOM.extendedPubKey.val(libs.elastosjs.getBip32ExtendedPublicKey(seed, coin, account, change));
36523e0d
NJ		 3532
3533 // Display the addresses and privkeys
3534 clearAddressesList();
3535 var initialAddressCount = parseInt(DOM.rowsToAdd.val());
3536 displayAddresses(0, initialAddressCount);
3537 }
3538
3539 function calcAddressForELA(seed, coin, account, change, index) {
3540 if (!isELA()) {
3541 return;
3542 }
3543
22f87669 3544 var publicKey = libs.elastosjs.getDerivedPublicKey(libs.elastosjs.getMasterPublicKey(seed), change, index);
36523e0d 3545 return {
22f87669 3546 privateKey: libs.elastosjs.getDerivedPrivateKey(seed, coin, account, change, index),
36523e0d 3547 publicKey: publicKey,
22f87669 3548 address: libs.elastosjs.getAddress(publicKey.toString('hex'))
36523e0d
NJ		 3549 };
3550 }
3551 // ELA - Elastos functions - end
3552
ebd8d4e8
IC		 3553 init();
3554
3555})();
A web tool for converting BIP39 mnemonic codes