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