X-Git-Url: https://git.immae.eu/?p=perso%2FImmae%2FProjets%2FCryptomonnaies%2FBIP39.git;a=blobdiff_plain;f=src%2Fjs%2Findex.js;h=68c74f6912f0ac7d97940d5d611ffd30384ced55;hp=da901f6af65a4739f11796f938ddc6aad7a8d2d8;hb=83b2f0f10e950c7a05717bbe20ecc4367557abb6;hpb=3dbf117928bb17d58cc54fa1faa9354c014e665b

diff --git a/src/js/index.js b/src/js/index.js
index da901f6..68c74f6 100644
--- a/src/js/index.js
+++ b/src/js/index.js
@@ -6,7 +6,7 @@
     var seed = null;
     var bip32RootKey = null;
     var bip32ExtendedKey = null;
-    var network = bitcoinjs.bitcoin.networks.bitcoin;
+    var network = libs.bitcoin.networks.bitcoin;
     var addressRowTemplate = $("#address-row-template");
 
     var showIndex = true;
@@ -15,9 +15,12 @@
     var showPrivKey = true;
     var showQr = false;
     var litecoinUseLtub = true;
+    var isDefaultBip44ChangeValue = true;
 
+    var entropyTypeAutoDetect = true;
     var entropyChangeTimeoutEvent = null;
     var phraseChangeTimeoutEvent = null;
+    var seedChangedTimeoutEvent = null;
     var rootKeyChangedTimeoutEvent = null;
 
     var generationProcesses = [];
@@ -32,6 +35,7 @@
     DOM.entropy = $(".entropy");
     DOM.entropyFiltered = DOM.entropyContainer.find(".filtered");
     DOM.entropyType = DOM.entropyContainer.find(".type");
+    DOM.entropyTypeInputs = DOM.entropyContainer.find("input[name='entropy-type']");
     DOM.entropyCrackTime = DOM.entropyContainer.find(".crack-time");
     DOM.entropyEventCount = DOM.entropyContainer.find(".event-count");
     DOM.entropyBits = DOM.entropyContainer.find(".bits");
@@ -44,6 +48,10 @@
     DOM.entropyWeakEntropyOverrideWarning = DOM.entropyContainer.find(".weak-entropy-override-warning");
     DOM.entropyFilterWarning = DOM.entropyContainer.find(".filter-warning");
     DOM.phrase = $(".phrase");
+    DOM.splitMnemonic = $(".splitMnemonic");
+    DOM.showSplitMnemonic = $(".showSplitMnemonic");
+    DOM.phraseSplit = $(".phraseSplit");
+    DOM.phraseSplitWarn = $(".phraseSplitWarn");
     DOM.passphrase = $(".passphrase");
     DOM.generateContainer = $(".generate-container");
     DOM.generate = $(".generate");
@@ -69,6 +77,7 @@
     DOM.bip44accountXprv = $("#bip44 .account-xprv");
     DOM.bip44accountXpub = $("#bip44 .account-xpub");
     DOM.bip44change = $("#bip44 .change");
+    DOM.defaultBip44ChangeValue = $("#bip44 .default-bip44-change-value");
     DOM.bip49unavailable = $("#bip49 .unavailable");
     DOM.bip49available = $("#bip49 .available");
     DOM.bip49path = $("#bip49-path");
@@ -87,6 +96,18 @@
     DOM.bip84accountXprv = $("#bip84 .account-xprv");
     DOM.bip84accountXpub = $("#bip84 .account-xpub");
     DOM.bip84change = $("#bip84 .change");
+    DOM.bip85 = $('.bip85');
+    DOM.showBip85 = $('.showBip85');
+    DOM.bip85Field = $('.bip85Field');
+    DOM.bip85application = $('#bip85-application');
+    DOM.bip85mnemonicLanguage = $('#bip85-mnemonic-language');
+    DOM.bip85mnemonicLanguageInput = $('.bip85-mnemonic-language-input');
+    DOM.bip85mnemonicLength = $('#bip85-mnemonic-length');
+    DOM.bip85mnemonicLengthInput = $('.bip85-mnemonic-length-input');
+    DOM.bip85index = $('#bip85-index');
+    DOM.bip85indexInput = $('.bip85-index-input');
+    DOM.bip85bytes = $('#bip85-bytes');
+    DOM.bip85bytesInput = $('.bip85-bytes-input');
     DOM.bip141unavailable = $("#bip141 .unavailable");
     DOM.bip141available = $("#bip141 .available");
     DOM.bip141path = $("#bip141-path");
@@ -126,19 +147,30 @@
         DOM.useEntropy.on("change", setEntropyVisibility);
         DOM.entropy.on("input", delayedEntropyChanged);
         DOM.entropyMnemonicLength.on("change", entropyChanged);
+        DOM.entropyTypeInputs.on("change", entropyTypeChanged);
         DOM.phrase.on("input", delayedPhraseChanged);
+        DOM.showSplitMnemonic.on("change", toggleSplitMnemonic);
         DOM.passphrase.on("input", delayedPhraseChanged);
         DOM.generate.on("click", generateClicked);
         DOM.more.on("click", showMore);
+        DOM.seed.on("input", delayedSeedChanged);
         DOM.rootKey.on("input", delayedRootKeyChanged);
+        DOM.showBip85.on('change', toggleBip85);
         DOM.litecoinUseLtub.on("change", litecoinUseLtubChanged);
         DOM.bip32path.on("input", calcForDerivationPath);
         DOM.bip44account.on("input", calcForDerivationPath);
+        DOM.bip44change.on("input", modifiedDefaultBip44ChangeValue);
         DOM.bip44change.on("input", calcForDerivationPath);
+        DOM.defaultBip44ChangeValue.on("click", resetDefaultBip44ChangeValue);
         DOM.bip49account.on("input", calcForDerivationPath);
         DOM.bip49change.on("input", calcForDerivationPath);
         DOM.bip84account.on("input", calcForDerivationPath);
         DOM.bip84change.on("input", calcForDerivationPath);
+        DOM.bip85application.on('input', calcBip85);
+        DOM.bip85mnemonicLanguage.on('change', calcBip85);
+        DOM.bip85mnemonicLength.on('change', calcBip85);
+        DOM.bip85index.on('input', calcBip85);
+        DOM.bip85bytes.on('input', calcBip85);
         DOM.bip141path.on("input", calcForDerivationPath);
         DOM.bip141semantics.on("change", tabChanged);
         DOM.tab.on("shown.bs.tab", tabChanged);
@@ -238,6 +270,8 @@
             if (entropy !== null) {
                 DOM.entropyMnemonicLength.val("raw");
                 DOM.entropy.val(entropy);
+                DOM.entropyTypeInputs.filter("[value='hexadecimal']").prop("checked", true);
+                entropyTypeAutoDetect = false;
             }
         }, 400);
     }
@@ -256,8 +290,10 @@
         var passphrase = DOM.passphrase.val();
         calcBip32RootKeyFromSeed(phrase, passphrase);
         calcForDerivationPath();
+        calcBip85();
         // Show the word indexes
         showWordIndexes();
+        writeSplitPhrase(phrase);
     }
 
     function tabChanged() {
@@ -304,6 +340,7 @@
             clearDisplay();
             clearEntropyFeedback();
             DOM.phrase.val("");
+            DOM.phraseSplit.val("");
             showValidationError("Blank entropy");
             return;
         }
@@ -326,6 +363,35 @@
         }
     }
 
+    function entropyTypeChanged() {
+        entropyTypeAutoDetect = false;
+        entropyChanged();
+    }
+
+    function delayedSeedChanged() {
+        // Warn if there is an existing mnemonic or passphrase.
+        if (DOM.phrase.val().length > 0 || DOM.passphrase.val().length > 0) {
+            if (!confirm("This will clear existing mnemonic and passphrase")) {
+                DOM.seed.val(seed);
+                return
+            }
+        }
+        hideValidationError();
+        showPending();
+        // Clear existing mnemonic and passphrase
+        DOM.phrase.val("");
+        DOM.phraseSplit.val("");
+        DOM.passphrase.val("");
+        DOM.rootKey.val("");
+        clearAddressesList();
+        clearDerivedKeys();
+        seed = null;
+        if (seedChangedTimeoutEvent != null) {
+            clearTimeout(seedChangedTimeoutEvent);
+        }
+        seedChangedTimeoutEvent = setTimeout(seedChanged, 400);
+    }
+
     function delayedRootKeyChanged() {
         // Warn if there is an existing mnemonic or passphrase.
         if (DOM.phrase.val().length > 0 || DOM.passphrase.val().length > 0) {
@@ -338,6 +404,7 @@
         showPending();
         // Clear existing mnemonic and passphrase
         DOM.phrase.val("");
+        DOM.phraseSplit.val("");
         DOM.passphrase.val("");
         seed = null;
         if (rootKeyChangedTimeoutEvent != null) {
@@ -346,6 +413,23 @@
         rootKeyChangedTimeoutEvent = setTimeout(rootKeyChanged, 400);
     }
 
+    function seedChanged() {
+        showPending();
+        hideValidationError();
+        seed = DOM.seed.val();
+        bip32RootKey = libs.bitcoin.HDNode.fromSeedHex(seed, network);
+        var rootKeyBase58 = bip32RootKey.toBase58();
+        DOM.rootKey.val(rootKeyBase58);
+        var errorText = validateRootKey(rootKeyBase58);
+        if (errorText) {
+            showValidationError(errorText);
+            return;
+        }
+        // Calculate and display
+        calcForDerivationPath();
+        calcBip85();
+    }
+
     function rootKeyChanged() {
         showPending();
         hideValidationError();
@@ -358,19 +442,98 @@
         // Calculate and display
         calcBip32RootKeyFromBase58(rootKeyBase58);
         calcForDerivationPath();
+        calcBip85();
     }
 
     function litecoinUseLtubChanged() {
         litecoinUseLtub = DOM.litecoinUseLtub.prop("checked");
         if (litecoinUseLtub) {
-            network = bitcoinjs.bitcoin.networks.litecoin;
+            network = libs.bitcoin.networks.litecoin;
         }
         else {
-            network = bitcoinjs.bitcoin.networks.litecoinXprv;
+            network = libs.bitcoin.networks.litecoinXprv;
         }
         phraseChanged();
     }
 
+    function toggleSplitMnemonic() {
+        if (DOM.showSplitMnemonic.prop("checked")) {
+            DOM.splitMnemonic.removeClass("hidden");
+        }
+        else {
+            DOM.splitMnemonic.addClass("hidden");
+        }
+    }
+
+    function toggleBip85() {
+      if (DOM.showBip85.prop('checked')) {
+        DOM.bip85.removeClass('hidden');
+        calcBip85();
+      } else {
+        DOM.bip85.addClass('hidden');
+      }
+    }
+
+    function toggleBip85Fields() {
+      if (DOM.showBip85.prop('checked')) {
+        DOM.bip85mnemonicLanguageInput.addClass('hidden');
+        DOM.bip85mnemonicLengthInput.addClass('hidden');
+        DOM.bip85bytesInput.addClass('hidden');
+
+        var app = DOM.bip85application.val();
+        if (app === 'bip39') {
+          DOM.bip85mnemonicLanguageInput.removeClass('hidden');
+          DOM.bip85mnemonicLengthInput.removeClass('hidden');
+        } else if (app === 'hex') {
+          DOM.bip85bytesInput.removeClass('hidden');
+        }
+      }
+    }
+
+    function calcBip85() {
+      if (!DOM.showBip85.prop('checked')) {
+        return
+      }
+
+      toggleBip85Fields();
+
+      var app = DOM.bip85application.val();
+
+      var phrase = DOM.phrase.val();
+      var passphrase = DOM.passphrase.val();
+      if (!phrase) {
+        return;
+      }
+      try {
+        var master = libs.bip85.BIP85.fromMnemonic(phrase, passphrase);
+
+        var result;
+
+        const index = parseInt(DOM.bip85index.val(), 10);
+
+        if (app === 'bip39') {
+          const language = parseInt(DOM.bip85mnemonicLanguage.val(), 10);
+          const length = parseInt(DOM.bip85mnemonicLength.val(), 10);
+
+          result = master.deriveBIP39(language, length, index).toMnemonic();
+        } else if (app === 'wif') {
+          result = master.deriveWIF(index).toWIF();
+        } else if (app === 'xprv') {
+          result = master.deriveXPRV(index).toXPRV();
+        } else if (app === 'hex') {
+          const bytes = parseInt(DOM.bip85bytes.val(), 10);
+
+          result = master.deriveHex(bytes, index).toEntropy();
+        }
+
+        hideValidationError();
+        DOM.bip85Field.val(result);
+      } catch (e) {
+        showValidationError('BIP85: ' + e.message);
+        DOM.bip85Field.val('');
+      }
+    }
+
     function calcForDerivationPath() {
         clearDerivedKeys();
         clearAddressesList();
@@ -494,9 +657,9 @@
 
     function calcBip32RootKeyFromSeed(phrase, passphrase) {
         seed = mnemonic.toSeed(phrase, passphrase);
-        bip32RootKey = bitcoinjs.bitcoin.HDNode.fromSeedHex(seed, network);
+        bip32RootKey = libs.bitcoin.HDNode.fromSeedHex(seed, network);
         if(isGRS())
-            bip32RootKey = groestlcoinjs.HDNode.fromSeedHex(seed, network);
+            bip32RootKey = libs.groestlcoinjs.HDNode.fromSeedHex(seed, network);
 
     }
 
@@ -510,18 +673,18 @@
         if (networkHasSegwit()) {
             var n = network;
             if ("baseNetwork" in n) {
-                n = bitcoinjs.bitcoin.networks[n.baseNetwork];
+                n = libs.bitcoin.networks[n.baseNetwork];
             }
             // try parsing using base network params
             try {
-                bip32RootKey = bitcoinjs.bitcoin.HDNode.fromBase58(rootKeyBase58, n);
+                bip32RootKey = libs.bitcoin.HDNode.fromBase58(rootKeyBase58, n);
                 return;
             }
             catch (e) {}
             // try parsing using p2wpkh params
             if ("p2wpkh" in n) {
                 try {
-                    bip32RootKey = bitcoinjs.bitcoin.HDNode.fromBase58(rootKeyBase58, n.p2wpkh);
+                    bip32RootKey = libs.bitcoin.HDNode.fromBase58(rootKeyBase58, n.p2wpkh);
                     return;
                 }
                 catch (e) {}
@@ -529,14 +692,30 @@
             // try parsing using p2wpkh-in-p2sh network params
             if ("p2wpkhInP2sh" in n) {
                 try {
-                    bip32RootKey = bitcoinjs.bitcoin.HDNode.fromBase58(rootKeyBase58, n.p2wpkhInP2sh);
+                    bip32RootKey = libs.bitcoin.HDNode.fromBase58(rootKeyBase58, n.p2wpkhInP2sh);
+                    return;
+                }
+                catch (e) {}
+            }
+            // try parsing using p2wsh network params
+            if ("p2wsh" in n) {
+                try {
+                    bip32RootKey = libs.bitcoin.HDNode.fromBase58(rootKeyBase58, n.p2wsh);
+                    return;
+                }
+                catch (e) {}
+            }
+            // try parsing using p2wsh-in-p2sh network params
+            if ("p2wshInP2sh" in n) {
+                try {
+                    bip32RootKey = libs.bitcoin.HDNode.fromBase58(rootKeyBase58, n.p2wshInP2sh);
                     return;
                 }
                 catch (e) {}
             }
         }
         // try the network params as currently specified
-        bip32RootKey = bitcoinjs.bitcoin.HDNode.fromBase58(rootKeyBase58, network);
+        bip32RootKey = libs.bitcoin.HDNode.fromBase58(rootKeyBase58, network);
     }
 
     function calcBip32RootKeyFromBase58GRS(rootKeyBase58) {
@@ -545,18 +724,18 @@
         if (networkHasSegwit()) {
             var n = network;
             if ("baseNetwork" in n) {
-                n = bitcoinjs.bitcoin.networks[n.baseNetwork];
+                n = libs.bitcoin.networks[n.baseNetwork];
             }
             // try parsing using base network params
             try {
-                bip32RootKey = groestlcoinjs.HDNode.fromBase58(rootKeyBase58, n);
+                bip32RootKey = libs.groestlcoinjs.HDNode.fromBase58(rootKeyBase58, n);
                 return;
             }
             catch (e) {}
             // try parsing using p2wpkh params
             if ("p2wpkh" in n) {
                 try {
-                    bip32RootKey = groestlcoinjs.HDNode.fromBase58(rootKeyBase58, n.p2wpkh);
+                    bip32RootKey = libs.groestlcoinjs.HDNode.fromBase58(rootKeyBase58, n.p2wpkh);
                     return;
                 }
                 catch (e) {}
@@ -564,14 +743,14 @@
             // try parsing using p2wpkh-in-p2sh network params
             if ("p2wpkhInP2sh" in n) {
                 try {
-                    bip32RootKey = groestlcoinjs.HDNode.fromBase58(rootKeyBase58, n.p2wpkhInP2sh);
+                    bip32RootKey = libs.groestlcoinjs.HDNode.fromBase58(rootKeyBase58, n.p2wpkhInP2sh);
                     return;
                 }
                 catch (e) {}
             }
         }
         // try the network params as currently specified
-        bip32RootKey = groestlcoinjs.HDNode.fromBase58(rootKeyBase58, network);
+        bip32RootKey = libs.groestlcoinjs.HDNode.fromBase58(rootKeyBase58, network);
     }
 
     function calcBip32ExtendedKey(path) {
@@ -601,7 +780,7 @@
                 extendedKey = extendedKey.derive(index);
             }
         }
-        return extendedKey
+        return extendedKey;
     }
 
     function showValidationError(errorText) {
@@ -644,26 +823,26 @@
     }
 
     function validateRootKey(rootKeyBase58) {
-        if(isGRS()) 
+        if(isGRS())
             return validateRootKeyGRS(rootKeyBase58);
-            
+
         // try various segwit network params since this extended key may be from
         // any one of them.
         if (networkHasSegwit()) {
             var n = network;
             if ("baseNetwork" in n) {
-                n = bitcoinjs.bitcoin.networks[n.baseNetwork];
+                n = libs.bitcoin.networks[n.baseNetwork];
             }
             // try parsing using base network params
             try {
-                bitcoinjs.bitcoin.HDNode.fromBase58(rootKeyBase58, n);
+                libs.bitcoin.HDNode.fromBase58(rootKeyBase58, n);
                 return "";
             }
             catch (e) {}
             // try parsing using p2wpkh params
             if ("p2wpkh" in n) {
                 try {
-                    bitcoinjs.bitcoin.HDNode.fromBase58(rootKeyBase58, n.p2wpkh);
+                    libs.bitcoin.HDNode.fromBase58(rootKeyBase58, n.p2wpkh);
                     return "";
                 }
                 catch (e) {}
@@ -671,7 +850,23 @@
             // try parsing using p2wpkh-in-p2sh network params
             if ("p2wpkhInP2sh" in n) {
                 try {
-                    bitcoinjs.bitcoin.HDNode.fromBase58(rootKeyBase58, n.p2wpkhInP2sh);
+                    libs.bitcoin.HDNode.fromBase58(rootKeyBase58, n.p2wpkhInP2sh);
+                    return "";
+                }
+                catch (e) {}
+            }
+            // try parsing using p2wsh network params
+            if ("p2wsh" in n) {
+                try {
+                    libs.bitcoin.HDNode.fromBase58(rootKeyBase58, n.p2wsh);
+                    return "";
+                }
+                catch (e) {}
+            }
+            // try parsing using p2wsh-in-p2sh network params
+            if ("p2wshInP2sh" in n) {
+                try {
+                    libs.bitcoin.HDNode.fromBase58(rootKeyBase58, n.p2wshInP2sh);
                     return "";
                 }
                 catch (e) {}
@@ -679,7 +874,7 @@
         }
         // try the network params as currently specified
         try {
-            bitcoinjs.bitcoin.HDNode.fromBase58(rootKeyBase58, network);
+            libs.bitcoin.HDNode.fromBase58(rootKeyBase58, network);
         }
         catch (e) {
             return "Invalid root key";
@@ -693,18 +888,18 @@
         if (networkHasSegwit()) {
             var n = network;
             if ("baseNetwork" in n) {
-                n = bitcoinjs.bitcoin.networks[n.baseNetwork];
+                n = libs.bitcoin.networks[n.baseNetwork];
             }
             // try parsing using base network params
             try {
-                groestlcoinjs.HDNode.fromBase58(rootKeyBase58, n);
+                libs.groestlcoinjs.HDNode.fromBase58(rootKeyBase58, n);
                 return "";
             }
             catch (e) {}
             // try parsing using p2wpkh params
             if ("p2wpkh" in n) {
                 try {
-                    groestlcoinjs.HDNode.fromBase58(rootKeyBase58, n.p2wpkh);
+                    libs.groestlcoinjs.HDNode.fromBase58(rootKeyBase58, n.p2wpkh);
                     return "";
                 }
                 catch (e) {}
@@ -712,7 +907,7 @@
             // try parsing using p2wpkh-in-p2sh network params
             if ("p2wpkhInP2sh" in n) {
                 try {
-                    groestlcoinjs.HDNode.fromBase58(rootKeyBase58, n.p2wpkhInP2sh);
+                    libs.groestlcoinjs.HDNode.fromBase58(rootKeyBase58, n.p2wpkhInP2sh);
                     return "";
                 }
                 catch (e) {}
@@ -720,7 +915,7 @@
         }
         // try the network params as currently specified
         try {
-            groestlcoinjs.HDNode.fromBase58(rootKeyBase58, network);
+            libs.groestlcoinjs.HDNode.fromBase58(rootKeyBase58, network);
         }
         catch (e) {
             return "Invalid root key";
@@ -733,12 +928,14 @@
             var purpose = parseIntNoNaN(DOM.bip44purpose.val(), 44);
             var coin = parseIntNoNaN(DOM.bip44coin.val(), 0);
             var account = parseIntNoNaN(DOM.bip44account.val(), 0);
-            var change = parseIntNoNaN(DOM.bip44change.val(), 0);
-            var path = "m/";
-            path += purpose + "'/";
-            path += coin + "'/";
-            path += account + "'/";
-            path += change;
+            var change = parseIntNoNaN(DOM.bip44change.val(), "");
+            var path = "m";
+            path += "/" + purpose + "'";
+            path += "/" + coin + "'";
+            path += "/" + account + "'";
+            if (change !== "") {
+              path += "/" + change;
+            }
             DOM.bip44path.val(path);
             var derivationPath = DOM.bip44path.val();
             console.log("Using derivation path from BIP44 tab: " + derivationPath);
@@ -842,6 +1039,10 @@
         return networks[DOM.network.val()].name == "GRS - Groestlcoin" || networks[DOM.network.val()].name == "GRS - Groestlcoin Testnet";
     }
 
+    function isELA() {
+        return networks[DOM.network.val()].name == "ELA - Elastos"
+    }
+
     function displayBip44Info() {
         // Get the derivation path for the account
         var purpose = parseIntNoNaN(DOM.bip44purpose.val(), 44);
@@ -855,9 +1056,14 @@
         var accountExtendedKey = calcBip32ExtendedKey(path);
         var accountXprv = accountExtendedKey.toBase58();
         var accountXpub = accountExtendedKey.neutered().toBase58();
+
         // Display the extended keys
         DOM.bip44accountXprv.val(accountXprv);
         DOM.bip44accountXpub.val(accountXpub);
+
+        if (isELA()) {
+            displayBip44InfoForELA();
+        }
     }
 
     function displayBip49Info() {
@@ -913,6 +1119,10 @@
         clearAddressesList();
         var initialAddressCount = parseInt(DOM.rowsToAdd.val());
         displayAddresses(0, initialAddressCount);
+
+        if (isELA()) {
+            displayBip32InfoForELA();
+        }
     }
 
     function displayAddresses(start, total) {
@@ -950,6 +1160,14 @@
             (bip141TabSelected() && DOM.bip141semantics.val() == "p2wpkh-p2sh");
     }
 
+    function p2wshSelected() {
+        return bip141TabSelected() && DOM.bip141semantics.val() == "p2wsh";
+    }
+
+    function p2wshInP2shSelected() {
+        return (bip141TabSelected() && DOM.bip141semantics.val() == "p2wsh-p2sh");
+    }
+
     function TableRow(index, isLast) {
 
         var self = this;
@@ -961,6 +1179,8 @@
         var segwitAvailable = networkHasSegwit();
         var isP2wpkh = p2wpkhSelected();
         var isP2wpkhInP2sh = p2wpkhInP2shSelected();
+        var isP2wsh = p2wshSelected();
+        var isP2wshInP2sh = p2wshInP2shSelected();
 
         function init() {
             calculateValues();
@@ -984,9 +1204,9 @@
                 var keyPair = key.keyPair;
                 var useUncompressed = useBip38;
                 if (useUncompressed) {
-                    keyPair = new bitcoinjs.bitcoin.ECPair(keyPair.d, null, { network: network, compressed: false });
+                    keyPair = new libs.bitcoin.ECPair(keyPair.d, null, { network: network, compressed: false });
                     if(isGRS())
-                        keyPair = new groestlcoinjs.ECPair(keyPair.d, null, { network: network, compressed: false });
+                        keyPair = new libs.groestlcoinjs.ECPair(keyPair.d, null, { network: network, compressed: false });
 
                 }
                 // get address
@@ -998,12 +1218,12 @@
                     privkey = keyPair.toWIF();
                     // BIP38 encode private key if required
                     if (useBip38) {
-                        if(isGRS())  
-                            privkey = groestlcoinjsBip38.encrypt(keyPair.d.toBuffer(), false, bip38password, function(p) {
+                        if(isGRS())
+                            privkey = libs.groestlcoinjsBip38.encrypt(keyPair.d.toBuffer(), false, bip38password, function(p) {
                                 console.log("Progressed " + p.percent.toFixed(1) + "% for index " + index);
                             }, null, networks[DOM.network.val()].name.includes("Testnet"));
                         else
-                            privkey = bitcoinjsBip38.encrypt(keyPair.d.toBuffer(), false, bip38password, function(p) {
+                            privkey = libs.bip38.encrypt(keyPair.d.toBuffer(), false, bip38password, function(p) {
                                 console.log("Progressed " + p.percent.toFixed(1) + "% for index " + index);
                             });
                     }
@@ -1015,27 +1235,62 @@
                     indexText = indexText + "'";
                 }
                 // Ethereum values are different
-                if ((networks[DOM.network.val()].name == "ETH - Ethereum")
-                    || (networks[DOM.network.val()].name == "ETC - Ethereum Classic")
-                    || (networks[DOM.network.val()].name == "PIRL - Pirl")
-                    || (networks[DOM.network.val()].name == "MIX - MIX")
-                    || (networks[DOM.network.val()].name == "MUSIC - Musicoin")
-                    || (networks[DOM.network.val()].name == "POA - Poa")
-                    || (networks[DOM.network.val()].name == "EXP - Expanse")
-                    || (networks[DOM.network.val()].name == "CLO - Callisto")
-                    || (networks[DOM.network.val()].name == "DXN - DEXON")
-                    || (networks[DOM.network.val()].name == "ELLA - Ellaism")
-                    || (networks[DOM.network.val()].name == "ESN - Ethersocial Network")
-                    || (networks[DOM.network.val()].name == "VET - VeChain")
-                ) {
-                    var privKeyBuffer = keyPair.d.toBuffer(32);
-                    privkey = privKeyBuffer.toString('hex');
-                    var addressBuffer = ethUtil.privateToAddress(privKeyBuffer);
+                if (networkIsEthereum()) {
+                    var pubkeyBuffer = keyPair.getPublicKeyBuffer();
+                    var ethPubkey = libs.ethUtil.importPublic(pubkeyBuffer);
+                    var addressBuffer = libs.ethUtil.publicToAddress(ethPubkey);
                     var hexAddress = addressBuffer.toString('hex');
-                    var checksumAddress = ethUtil.toChecksumAddress(hexAddress);
-                    address = ethUtil.addHexPrefix(checksumAddress);
-                    privkey = ethUtil.addHexPrefix(privkey);
-                    pubkey = ethUtil.addHexPrefix(pubkey);
+                    var checksumAddress = libs.ethUtil.toChecksumAddress(hexAddress);
+                    address = libs.ethUtil.addHexPrefix(checksumAddress);
+                    pubkey = libs.ethUtil.addHexPrefix(pubkey);
+                    if (hasPrivkey) {
+                        privkey = libs.ethUtil.bufferToHex(keyPair.d.toBuffer(32));
+                    }
+                }
+                //TRX is different
+                if (networks[DOM.network.val()].name == "TRX - Tron") {
+                    keyPair = new libs.bitcoin.ECPair(keyPair.d, null, { network: network, compressed: false });
+                    var pubkeyBuffer = keyPair.getPublicKeyBuffer();
+                    var ethPubkey = libs.ethUtil.importPublic(pubkeyBuffer);
+                    var addressBuffer = libs.ethUtil.publicToAddress(ethPubkey);
+                    address = libs.bitcoin.address.toBase58Check(addressBuffer, 0x41);
+                    if (hasPrivkey) {
+                        privkey = keyPair.d.toBuffer().toString('hex');
+                    }
+                }
+
+                // RSK values are different
+                if (networkIsRsk()) {
+                    var pubkeyBuffer = keyPair.getPublicKeyBuffer();
+                    var ethPubkey = libs.ethUtil.importPublic(pubkeyBuffer);
+                    var addressBuffer = libs.ethUtil.publicToAddress(ethPubkey);
+                    var hexAddress = addressBuffer.toString('hex');
+                    // Use chainId based on selected network
+                    // Ref: https://developers.rsk.co/rsk/architecture/account-based/#chainid
+                    var chainId;
+                    var rskNetworkName = networks[DOM.network.val()].name;
+                    switch (rskNetworkName) {
+                        case "R-BTC - RSK":
+                            chainId = 30;
+                            break;
+                        case "tR-BTC - RSK Testnet":
+                            chainId = 31;
+                            break;
+                        default:
+                            chainId = null;
+                    }
+                    var checksumAddress = toChecksumAddressForRsk(hexAddress, chainId);
+                    address = libs.ethUtil.addHexPrefix(checksumAddress);
+                    pubkey = libs.ethUtil.addHexPrefix(pubkey);
+                    if (hasPrivkey) {
+                        privkey = libs.ethUtil.bufferToHex(keyPair.d.toBuffer());
+                    }
+                }
+
+                // Handshake values are different
+                if (networks[DOM.network.val()].name == "HNS - Handshake") {
+                    var ring = libs.handshake.KeyRing.fromPublic(keyPair.getPublicKeyBuffer())
+                    address = ring.getAddress().toString();
                 }
 
                 // Stellar is different
@@ -1045,15 +1300,23 @@
                     var path = "m/";
                         path += purpose + "'/";
                         path += coin + "'/" + index + "'";
-                    var keypair = stellarUtil.getKeypair(path, seed);
+                    var keypair = libs.stellarUtil.getKeypair(path, seed);
                     indexText = path;
                     privkey = keypair.secret();
                     pubkey = address = keypair.publicKey();
                 }
+
+                // Nano currency
+                if (networks[DOM.network.val()].name == "NANO - Nano") {
+                    var nanoKeypair = libs.nanoUtil.getKeypair(index, seed);
+                    privkey = nanoKeypair.privKey;
+                    pubkey = nanoKeypair.pubKey;
+                    address = nanoKeypair.address;
+                }
+
                 if ((networks[DOM.network.val()].name == "NAS - Nebulas")) {
-                    var NasAccount = require("nebulas-account");
                     var privKeyBuffer = keyPair.d.toBuffer(32);
-                    var nebulasAccount = new NasAccount();
+                    var nebulasAccount = libs.nebulas.Account.NewAccount();
                     nebulasAccount.setPrivateKey(privKeyBuffer);
                     address = nebulasAccount.getAddressString();
                     privkey = nebulasAccount.getPrivateKeyString();
@@ -1064,6 +1327,11 @@
                     privkey = convertRipplePriv(privkey);
                     address = convertRippleAdrr(address);
                 }
+                // Jingtum values are different
+                if (networks[DOM.network.val()].name == "SWTC - Jingtum") {
+                    privkey = convertJingtumPriv(privkey);
+                    address = convertJingtumAdrr(address);
+                }
                 // CasinoCoin values are different
                 if (networks[DOM.network.val()].name == "CSC - CasinoCoin") {
                     privkey = convertCasinoCoinPriv(privkey);
@@ -1073,46 +1341,94 @@
                 if (networks[DOM.network.val()].name == "BCH - Bitcoin Cash") {
                     var bchAddrType = DOM.bitcoinCashAddressType.filter(":checked").val();
                     if (bchAddrType == "cashaddr") {
-                        address = bchaddr.toCashAddress(address);
+                        address = libs.bchaddr.toCashAddress(address);
                     }
                     else if (bchAddrType == "bitpay") {
-                        address = bchaddr.toBitpayAddress(address);
+                        address = libs.bchaddr.toBitpayAddress(address);
                     }
                 }
                  // Bitcoin Cash address format may vary
                  if (networks[DOM.network.val()].name == "SLP - Simple Ledger Protocol") {
                      var bchAddrType = DOM.bitcoinCashAddressType.filter(":checked").val();
                      if (bchAddrType == "cashaddr") {
-                         address = bchaddr.toSlpAddress(address);
+                         address = libs.bchaddrSlp.toSlpAddress(address);
                      }
                  }
+
+                // ZooBC address format may vary
+                if (networks[DOM.network.val()].name == "ZBC - ZooBlockchain") {  
+                    
+                    var purpose = parseIntNoNaN(DOM.bip44purpose.val(), 44);
+                    var coin = parseIntNoNaN(DOM.bip44coin.val(), 0);
+                    var path = "m/";
+                        path += purpose + "'/";
+                        path += coin + "'/" + index + "'";
+                    var result = libs.zoobcUtil.getKeypair(path, seed);
+    
+                    let publicKey = result.pubKey.slice(1, 33);
+                    let privateKey = result.key;
+    
+                    privkey = privateKey.toString('hex');
+                    pubkey = publicKey.toString('hex');
+    
+                    indexText = path;
+                    address = libs.zoobcUtil.getZBCAddress(publicKey, 'ZBC');
+                }
+
                 // Segwit addresses are different
                 if (isSegwit) {
                     if (!segwitAvailable) {
                         return;
                     }
                     if (isP2wpkh) {
-                        var keyhash = bitcoinjs.bitcoin.crypto.hash160(key.getPublicKeyBuffer());
-                        var scriptpubkey = bitcoinjs.bitcoin.script.witnessPubKeyHash.output.encode(keyhash);
-                        address = bitcoinjs.bitcoin.address.fromOutputScript(scriptpubkey, network)
+                        var keyhash = libs.bitcoin.crypto.hash160(key.getPublicKeyBuffer());
+                        var scriptpubkey = libs.bitcoin.script.witnessPubKeyHash.output.encode(keyhash);
+                        address = libs.bitcoin.address.fromOutputScript(scriptpubkey, network)
                     }
                     else if (isP2wpkhInP2sh) {
-                        var keyhash = bitcoinjs.bitcoin.crypto.hash160(key.getPublicKeyBuffer());
-                        var scriptsig = bitcoinjs.bitcoin.script.witnessPubKeyHash.output.encode(keyhash);
-                        var addressbytes = bitcoinjs.bitcoin.crypto.hash160(scriptsig);
-                        var scriptpubkey = bitcoinjs.bitcoin.script.scriptHash.output.encode(addressbytes);
-                        address = bitcoinjs.bitcoin.address.fromOutputScript(scriptpubkey, network)
+                        var keyhash = libs.bitcoin.crypto.hash160(key.getPublicKeyBuffer());
+                        var scriptsig = libs.bitcoin.script.witnessPubKeyHash.output.encode(keyhash);
+                        var addressbytes = libs.bitcoin.crypto.hash160(scriptsig);
+                        var scriptpubkey = libs.bitcoin.script.scriptHash.output.encode(addressbytes);
+                        address = libs.bitcoin.address.fromOutputScript(scriptpubkey, network)
+                    }
+                    else if (isP2wsh) {
+                        // https://github.com/libs.bitcoinjs-lib/blob/v3.3.2/test/integration/addresses.js#L71
+                        // This is a 1-of-1
+                        var witnessScript = libs.bitcoin.script.multisig.output.encode(1, [key.getPublicKeyBuffer()]);
+                        var scriptPubKey = libs.bitcoin.script.witnessScriptHash.output.encode(libs.bitcoin.crypto.sha256(witnessScript));
+                        address = libs.bitcoin.address.fromOutputScript(scriptPubKey, network);
+                    }
+                    else if (isP2wshInP2sh) {
+                        // https://github.com/libs.bitcoinjs-lib/blob/v3.3.2/test/integration/transactions.js#L183
+                        // This is a 1-of-1
+                        var witnessScript = libs.bitcoin.script.multisig.output.encode(1, [key.getPublicKeyBuffer()]);
+                        var redeemScript = libs.bitcoin.script.witnessScriptHash.output.encode(libs.bitcoin.crypto.sha256(witnessScript));
+                        var scriptPubKey = libs.bitcoin.script.scriptHash.output.encode(libs.bitcoin.crypto.hash160(redeemScript));
+                        address = libs.bitcoin.address.fromOutputScript(scriptPubKey, network)
                     }
                 }
 
                 if ((networks[DOM.network.val()].name == "CRW - Crown")) {
-                    address = bitcoinjs.bitcoin.networks.crown.toNewAddress(address);
+                    address = libs.bitcoin.networks.crown.toNewAddress(address);
                 }
 
               if (networks[DOM.network.val()].name == "EOS - EOSIO") {
                     address = ""
-                    pubkey = eosUtil.bufferToPublic(keyPair.getPublicKeyBuffer());
-                    privkey = eosUtil.bufferToPrivate(keyPair.d.toBuffer(32));
+                    pubkey = EOSbufferToPublic(keyPair.getPublicKeyBuffer());
+                    privkey = EOSbufferToPrivate(keyPair.d.toBuffer(32));
+                }
+
+                if (networks[DOM.network.val()].name == "FIO - Foundation for Interwallet Operability") {
+                    address = ""
+                    pubkey = FIObufferToPublic(keyPair.getPublicKeyBuffer());
+                    privkey = FIObufferToPrivate(keyPair.d.toBuffer(32));
+                }
+
+                if (networks[DOM.network.val()].name == "ATOM - Cosmos Hub") {
+                    address = CosmosBufferToAddress(keyPair.getPublicKeyBuffer());
+                    pubkey = CosmosBufferToPublic(keyPair.getPublicKeyBuffer());
+                    privkey = keyPair.d.toBuffer().toString("base64");
                 }
 
                 //Groestlcoin Addresses are different
@@ -1123,15 +1439,28 @@
                             return;
                         }
                         if (isP2wpkh) {
-                            address = groestlcoinjs.address.fromOutputScript(scriptpubkey, network)
+                            address = libs.groestlcoinjs.address.fromOutputScript(scriptpubkey, network)
                         }
                         else if (isP2wpkhInP2sh) {
-                            address = groestlcoinjs.address.fromOutputScript(scriptpubkey, network)
+                            address = libs.groestlcoinjs.address.fromOutputScript(scriptpubkey, network)
                         }
-                    } 
+                    }
                     //non-segwit addresses are handled by using groestlcoinjs for bip32RootKey
                 }
 
+                if (isELA()) {
+                    let elaAddress = calcAddressForELA(
+                        seed,
+                        parseIntNoNaN(DOM.bip44coin.val(), 0),
+                        parseIntNoNaN(DOM.bip44account.val(), 0),
+                        parseIntNoNaN(DOM.bip44change.val(), 0),
+                        index
+                    );
+                    address = elaAddress.address;
+                    privkey = elaAddress.privateKey;
+                    pubkey = elaAddress.publicKey;
+                }
+
                 addAddressToList(indexText, address, pubkey, privkey);
                 if (isLast) {
                     hidePending();
@@ -1267,7 +1596,7 @@
             if (comparedTo.indexOf(word) == 0) {
                 return comparedTo;
             }
-            var distance = Levenshtein.get(word, comparedTo);
+            var distance = libs.levenshtein.get(word, comparedTo);
             if (distance < minDistance) {
                 closestWord = comparedTo;
                 minDistance = distance;
@@ -1423,6 +1752,49 @@
         return phrase;
     }
 
+    function writeSplitPhrase(phrase) {
+        var wordCount = phrase.split(/\s/g).length;
+        var left=[];
+        for (var i=0;i<wordCount;i++) left.push(i);
+        var group=[[],[],[]],
+            groupI=-1;
+        var seed = Math.abs(sjcl.hash.sha256.hash(phrase)[0])% 2147483647;
+        while (left.length>0) {
+            groupI=(groupI+1)%3;
+            seed = seed * 16807 % 2147483647;
+            var selected=Math.floor(left.length*(seed - 1) / 2147483646);
+            group[groupI].push(left[selected]);
+            left.splice(selected,1);
+        }
+        var cards=[phrase.split(/\s/g),phrase.split(/\s/g),phrase.split(/\s/g)];
+        for (var i=0;i<3;i++) {
+            for (var ii=0;ii<wordCount/3;ii++) cards[i][group[i][ii]]='XXXX';
+            cards[i]='Card '+(i+1)+': '+wordArrayToPhrase(cards[i]);
+        }
+        DOM.phraseSplit.val(cards.join("\r\n"));
+        var triesPerSecond=10000000000;
+        var hackTime=Math.pow(2,wordCount*10/3)/triesPerSecond;
+        var displayRedText = false;
+        if (hackTime<1) {
+            hackTime="<1 second";
+            displayRedText = true;
+        } else if (hackTime<86400) {
+            hackTime=Math.floor(hackTime)+" seconds";
+            displayRedText = true;
+        } else if(hackTime<31557600) {
+            hackTime=Math.floor(hackTime/86400)+" days";
+            displayRedText = true;
+        } else {
+            hackTime=Math.floor(hackTime/31557600)+" years";
+        }
+        DOM.phraseSplitWarn.html("Time to hack with only one card: "+hackTime);
+        if (displayRedText) {
+            DOM.phraseSplitWarn.addClass("text-danger");
+        } else {
+            DOM.phraseSplitWarn.removeClass("text-danger");
+        }
+    }
+
     function isUsingOwnEntropy() {
         return DOM.useEntropy.prop("checked");
     }
@@ -1432,7 +1804,14 @@
         // Get entropy value
         var entropyStr = DOM.entropy.val();
         // Work out minimum base for entropy
-        var entropy = Entropy.fromString(entropyStr);
+        var entropy = null;
+        if (entropyTypeAutoDetect) {
+            entropy = Entropy.fromString(entropyStr);
+        }
+        else {
+            let base = DOM.entropyTypeInputs.filter(":checked").val();
+            entropy = Entropy.fromString(entropyStr, base);
+        }
         if (entropy.binaryStr.length == 0) {
             return;
         }
@@ -1445,7 +1824,7 @@
             // Get bits by hashing entropy with SHA256
             var hash = sjcl.hash.sha256.hash(entropy.cleanStr);
             var hex = sjcl.codec.hex.fromBits(hash);
-            bits = BigInteger.parse(hex, 16).toString(2);
+            bits = libs.BigInteger.BigInteger.parse(hex, 16).toString(2);
             while (bits.length % 256 != 0) {
                 bits = "0" + bits;
             }
@@ -1480,6 +1859,7 @@
         var phrase = mnemonic.toMnemonic(entropyArr);
         // Set the mnemonic in the UI
         DOM.phrase.val(phrase);
+        writeSplitPhrase(phrase);
         // Show the word indexes
         showWordIndexes();
         // Show the checksum
@@ -1501,7 +1881,7 @@
         var numberOfBits = entropy.binaryStr.length;
         var timeToCrack = "unknown";
         try {
-            var z = zxcvbn(entropy.base.parts.join(""));
+            var z = libs.zxcvbn(entropy.base.events.join(""));
             timeToCrack = z.crack_times_display.offline_fast_hashing_1e10_per_second;
             if (z.feedback.warning != "") {
                 timeToCrack = timeToCrack + " - " + z.feedback.warning;
@@ -1512,13 +1892,15 @@
             console.log(e);
         }
         var entropyTypeStr = getEntropyTypeStr(entropy);
+        DOM.entropyTypeInputs.attr("checked", false);
+        DOM.entropyTypeInputs.filter("[value='" + entropyTypeStr + "']").attr("checked", true);
         var wordCount = Math.floor(numberOfBits / 32) * 3;
         var bitsPerEvent = entropy.bitsPerEvent.toFixed(2);
         var spacedBinaryStr = addSpacesEveryElevenBits(entropy.binaryStr);
         DOM.entropyFiltered.html(entropy.cleanHtml);
         DOM.entropyType.text(entropyTypeStr);
         DOM.entropyCrackTime.text(timeToCrack);
-        DOM.entropyEventCount.text(entropy.base.ints.length);
+        DOM.entropyEventCount.text(entropy.base.events.length);
         DOM.entropyBits.text(numberOfBits);
         DOM.entropyWordCount.text(wordCount);
         DOM.entropyBinary.text(spacedBinaryStr);
@@ -1543,8 +1925,8 @@
             // Detect duplicates
             var dupes = [];
             var dupeTracker = {};
-            for (var i=0; i<entropy.base.parts.length; i++) {
-                var card = entropy.base.parts[i];
+            for (var i=0; i<entropy.base.events.length; i++) {
+                var card = entropy.base.events[i];
                 var cardUpper = card.toUpperCase();
                 if (cardUpper in dupeTracker) {
                     dupes.push(card);
@@ -1607,7 +1989,7 @@
     function createQr(e) {
         var content = e.target.textContent || e.target.value;
         if (content) {
-            var qrEl = kjua({
+            var qrEl = libs.kjua({
                 text: content,
                 render: "canvas",
                 size: 310,
@@ -1643,10 +2025,36 @@
         return DOM.bip32tab.hasClass("active");
     }
 
+    function networkIsEthereum() {
+        var name = networks[DOM.network.val()].name;
+        return (name == "ETH - Ethereum")
+                    || (name == "ETC - Ethereum Classic")
+                    || (name == "EWT - EnergyWeb")
+                    || (name == "PIRL - Pirl")
+                    || (name == "MIX - MIX")
+                    || (name == "MOAC - MOAC")
+                    || (name == "MUSIC - Musicoin")
+                    || (name == "POA - Poa")
+                    || (name == "EXP - Expanse")
+                    || (name == "CLO - Callisto")
+                    || (name == "DXN - DEXON")
+                    || (name == "ELLA - Ellaism")
+                    || (name == "ESN - Ethersocial Network")
+                    || (name == "VET - VeChain")
+                    || (name == "ERE - EtherCore")
+                    || (name == "BSC - Binance Smart Chain")
+    }
+
+    function networkIsRsk() {
+        var name = networks[DOM.network.val()].name;
+        return (name == "R-BTC - RSK")
+            || (name == "tR-BTC - RSK Testnet");
+    }
+
     function networkHasSegwit() {
         var n = network;
         if ("baseNetwork" in network) {
-            n = bitcoinjs.bitcoin.networks[network.baseNetwork];
+            n = libs.bitcoin.networks[network.baseNetwork];
         }
         // check if only p2wpkh params are required
         if (p2wpkhSelected()) {
@@ -1672,10 +2080,30 @@
         return DOM.bip141tab.hasClass("active");
     }
 
+    function setBip44ChangeValue() {
+        if (isDefaultBip44ChangeValue) {
+            if (networkIsEthereum()) {
+                DOM.bip44change.val("");
+            } else {
+                DOM.bip44change.val(0);
+            }
+        }
+    }
+
+    function modifiedDefaultBip44ChangeValue() {
+        isDefaultBip44ChangeValue = false;
+    }
+
+    function resetDefaultBip44ChangeValue() {
+        isDefaultBip44ChangeValue = true;
+        setBip44ChangeValue();
+    }
+
     function setHdCoin(coinValue) {
         DOM.bip44coin.val(coinValue);
         DOM.bip49coin.val(coinValue);
         DOM.bip84coin.val(coinValue);
+        setBip44ChangeValue();
     }
 
     function showSegwitAvailable() {
@@ -1705,7 +2133,7 @@
         // if a segwit network is alread selected, need to use base network to
         // look up new parameters
         if ("baseNetwork" in network) {
-            network = bitcoinjs.bitcoin.networks[network.baseNetwork];
+            network = libs.bitcoin.networks[network.baseNetwork];
         }
         // choose the right segwit params
         if (p2wpkhSelected() && "p2wpkh" in network) {
@@ -1714,6 +2142,12 @@
         else if (p2wpkhInP2shSelected() && "p2wpkhInP2sh" in network) {
             network = network.p2wpkhInP2sh;
         }
+        else if (p2wshSelected() && "p2wsh" in network) {
+            network = network.p2wsh;
+        }
+        else if (p2wshInP2shSelected() && "p2wshInP2sh" in network) {
+            network = network.p2wshInP2sh;
+        }
     }
 
     function lastIndexInTable() {
@@ -1807,56 +2241,70 @@
         {
             name: "AC - Asiacoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.asiacoin;
+                network = libs.bitcoin.networks.asiacoin;
                 setHdCoin(51);
             },
         },
         {
             name: "ACC - Adcoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.adcoin;
+                network = libs.bitcoin.networks.adcoin;
                 setHdCoin(161);
             },
         },
+        {
+            name: "AGM - Argoneum",
+            onSelect: function() {
+                network = libs.bitcoin.networks.argoneum;
+                setHdCoin(421);
+            },
+        },
         {
             name: "ARYA - Aryacoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.aryacoin;
+                network = libs.bitcoin.networks.aryacoin;
                 setHdCoin(357);
             },
         },
+        {
+            name: "ATOM - Cosmos Hub",
+            onSelect: function() {
+                network = libs.bitcoin.networks.bitcoin;
+                setHdCoin(118);
+            },
+        },
         {
             name: "AUR - Auroracoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.auroracoin;
+                network = libs.bitcoin.networks.auroracoin;
                 setHdCoin(85);
             },
         },
         {
             name: "AXE - Axe",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.axe;
+                network = libs.bitcoin.networks.axe;
                 setHdCoin(4242);
             },
-		},
-		{
+        },
+        {
             name: "ANON - ANON",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.anon;
+                network = libs.bitcoin.networks.anon;
                 setHdCoin(220);
             },
         },
         {
             name: "BOLI - Bolivarcoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.bolivarcoin;
+                network = libs.bitcoin.networks.bolivarcoin;
                 setHdCoin(278);
             },
         },
         {
             name: "BCA - Bitcoin Atom",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.atom;
+                network = libs.bitcoin.networks.atom;
                 setHdCoin(185);
             },
         },
@@ -1870,154 +2318,170 @@
         {
             name: "BEET - Beetlecoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.beetlecoin;
+                network = libs.bitcoin.networks.beetlecoin;
                 setHdCoin(800);
             },
         },
         {
             name: "BELA - Belacoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.belacoin;
+                network = libs.bitcoin.networks.belacoin;
                 setHdCoin(73);
             },
         },
         {
             name: "BLK - BlackCoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.blackcoin;
+                network = libs.bitcoin.networks.blackcoin;
                 setHdCoin(10);
             },
         },
         {
             name: "BND - Blocknode",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.blocknode;
+                network = libs.bitcoin.networks.blocknode;
                 setHdCoin(2941);
             },
         },
-		{
+        {
             name: "tBND - Blocknode Testnet",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.blocknode_testnet;
+                network = libs.bitcoin.networks.blocknode_testnet;
                 setHdCoin(1);
             },
         },
         {
             name: "BRIT - Britcoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.britcoin;
+                network = libs.bitcoin.networks.britcoin;
                 setHdCoin(70);
             },
         },
         {
             name: "BSD - Bitsend",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.bitsend;
+                network = libs.bitcoin.networks.bitsend;
                 setHdCoin(91);
             },
         },
-		{
+        {
             name: "BST - BlockStamp",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.blockstamp;
+                network = libs.bitcoin.networks.blockstamp;
                 setHdCoin(254);
             },
         },
         {
             name: "BTA - Bata",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.bata;
+                network = libs.bitcoin.networks.bata;
                 setHdCoin(89);
             },
         },
         {
             name: "BTC - Bitcoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.bitcoin;
+                network = libs.bitcoin.networks.bitcoin;
                 setHdCoin(0);
             },
         },
+        {
+            name: "BTC - Bitcoin RegTest",
+            onSelect: function() {
+                network = libs.bitcoin.networks.regtest;
+                // Using hd coin value 1 based on bip44_coin_type
+                // https://github.com/chaintope/bitcoinrb/blob/f1014406f6b8f9b4edcecedc18df70c80df06f11/lib/bitcoin/chainparams/regtest.yml
+                setHdCoin(1);
+            },
+        },
         {
             name: "BTC - Bitcoin Testnet",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.testnet;
+                network = libs.bitcoin.networks.testnet;
                 setHdCoin(1);
             },
         },
-		{
+        {
             name: "BITG - Bitcoin Green",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.bitcoingreen;
+                network = libs.bitcoin.networks.bitcoingreen;
                 setHdCoin(222);
             },
         },
         {
             name: "BTCP - Bitcoin Private",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.bitcoinprivate;
+                network = libs.bitcoin.networks.bitcoinprivate;
                 setHdCoin(183);
             },
         },
+        {
+            name: "BSC - Binance Smart Chain",
+            onSelect: function() {
+                network = libs.bitcoin.networks.bitcoin;
+                setHdCoin(60);
+            },
+        },
         {
             name: "BSV - BitcoinSV",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.bitcoinsv;
+                network = libs.bitcoin.networks.bitcoinsv;
                 setHdCoin(236);
             },
         },
         {
             name: "BTCZ - Bitcoinz",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.bitcoinz;
+                network = libs.bitcoin.networks.bitcoinz;
                 setHdCoin(177);
             },
         },
         {
             name: "BTDX - BitCloud",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.bitcloud;
+                network = libs.bitcoin.networks.bitcloud;
                 setHdCoin(218);
             },
         },
         {
             name: "BTG - Bitcoin Gold",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.bgold;
+                network = libs.bitcoin.networks.bgold;
                 setHdCoin(156);
             },
         },
         {
             name: "BTX - Bitcore",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.bitcore;
+                network = libs.bitcoin.networks.bitcore;
                 setHdCoin(160);
             },
         },
         {
             name: "CCN - Cannacoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.cannacoin;
+                network = libs.bitcoin.networks.cannacoin;
                 setHdCoin(19);
             },
         },
         {
             name: "CESC - Cryptoescudo",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.cannacoin;
+                network = libs.bitcoin.networks.cannacoin;
                 setHdCoin(111);
             },
         },
         {
             name: "CDN - Canadaecoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.canadaecoin;
+                network = libs.bitcoin.networks.canadaecoin;
                 setHdCoin(34);
             },
         },
         {
             name: "CLAM - Clams",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.clam;
+                network = libs.bitcoin.networks.clam;
                 setHdCoin(23);
             },
         },
@@ -2025,184 +2489,207 @@
             name: "CLO - Callisto",
             segwitAvailable: false,
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.bitcoin;
+                network = libs.bitcoin.networks.bitcoin;
                 setHdCoin(820);
             },
         },
         {
             name: "CLUB - Clubcoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.clubcoin;
+                network = libs.bitcoin.networks.clubcoin;
                 setHdCoin(79);
             },
         },
         {
             name: "CMP - Compcoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.compcoin;
+                network = libs.bitcoin.networks.compcoin;
                 setHdCoin(71);
             },
         },
         {
             name: "CPU - CPUchain",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.cpuchain;
+                network = libs.bitcoin.networks.cpuchain;
                 setHdCoin(363);
             },
         },
         {
             name: "CRAVE - Crave",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.crave;
+                network = libs.bitcoin.networks.crave;
                 setHdCoin(186);
             },
         },
+        {
+            name: "CRP - CranePay",
+            onSelect: function() {
+                network = libs.bitcoin.networks.cranepay;
+                setHdCoin(2304);
+            },
+        },
+
         {
             name: "CRW - Crown (Legacy)",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.crown;
+                network = libs.bitcoin.networks.crown;
                 setHdCoin(72);
             },
         },
         {
             name: "CRW - Crown",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.crown;
+                network = libs.bitcoin.networks.crown;
                 setHdCoin(72);
             },
         },
         {
             name: "CSC - CasinoCoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.bitcoin;
+                network = libs.bitcoin.networks.bitcoin;
                 setHdCoin(359);
             },
         },
         {
             name: "DASH - Dash",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.dash;
+                network = libs.bitcoin.networks.dash;
                 setHdCoin(5);
             },
         },
         {
             name: "DASH - Dash Testnet",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.dashtn;
+                network = libs.bitcoin.networks.dashtn;
                 setHdCoin(1);
             },
         },
         {
             name: "DFC - Defcoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.defcoin;
+                network = libs.bitcoin.networks.defcoin;
                 setHdCoin(1337);
             },
         },
         {
             name: "DGB - Digibyte",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.digibyte;
+                network = libs.bitcoin.networks.digibyte;
                 setHdCoin(20);
             },
         },
         {
             name: "DGC - Digitalcoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.digitalcoin;
+                network = libs.bitcoin.networks.digitalcoin;
                 setHdCoin(18);
             },
         },
         {
             name: "DMD - Diamond",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.diamond;
+                network = libs.bitcoin.networks.diamond;
                 setHdCoin(152);
             },
         },
         {
             name: "DNR - Denarius",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.denarius;
+                network = libs.bitcoin.networks.denarius;
                 setHdCoin(116);
             },
         },
         {
             name: "DOGE - Dogecoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.dogecoin;
+                network = libs.bitcoin.networks.dogecoin;
                 setHdCoin(3);
             },
         },
         {
             name: "DOGEt - Dogecoin Testnet",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.dogecointestnet;
+                network = libs.bitcoin.networks.dogecointestnet;
                 setHdCoin(1);
             },
         },
         {
             name: "DXN - DEXON",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.bitcoin;
+                network = libs.bitcoin.networks.bitcoin;
                 setHdCoin(237);
             },
         },
         {
             name: "ECN - Ecoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.ecoin;
+                network = libs.bitcoin.networks.ecoin;
                 setHdCoin(115);
             },
         },
         {
             name: "EDRC - Edrcoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.edrcoin;
+                network = libs.bitcoin.networks.edrcoin;
                 setHdCoin(56);
             },
         },
         {
             name: "EFL - Egulden",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.egulden;
+                network = libs.bitcoin.networks.egulden;
                 setHdCoin(78);
             },
         },
+        {
+            name: "ELA - Elastos",
+            onSelect: function () {
+                network = libs.bitcoin.networks.elastos;
+                setHdCoin(2305);
+            },
+        },
         {
             name: "ELLA - Ellaism",
             segwitAvailable: false,
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.bitcoin;
+                network = libs.bitcoin.networks.bitcoin;
                 setHdCoin(163);
             },
         },
         {
             name: "EMC2 - Einsteinium",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.einsteinium;
+                network = libs.bitcoin.networks.einsteinium;
                 setHdCoin(41);
             },
         },
         {
             name: "ERC - Europecoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.europecoin;
+                network = libs.bitcoin.networks.europecoin;
                 setHdCoin(151);
             },
         },
         {
             name: "EOS - EOSIO",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.bitcoin;
+                network = libs.bitcoin.networks.bitcoin;
                 setHdCoin(194);
             },
         },
+        {
+            name: "ERE - EtherCore",
+            segwitAvailable: false,
+            onSelect: function() {
+                network = libs.bitcoin.networks.bitcoin;
+                setHdCoin(466);
+            },
+        },
         {
             name: "ESN - Ethersocial Network",
             segwitAvailable: false,
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.bitcoin;
+                network = libs.bitcoin.networks.bitcoin;
                 setHdCoin(31102);
             },
         },
@@ -2210,28 +2697,35 @@
             name: "ETC - Ethereum Classic",
             segwitAvailable: false,
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.bitcoin;
+                network = libs.bitcoin.networks.bitcoin;
                 setHdCoin(61);
             },
         },
         {
             name: "ETH - Ethereum",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.bitcoin;
+                network = libs.bitcoin.networks.bitcoin;
                 setHdCoin(60);
             },
-        },
+          },
+        {
+            name: "EWT - EnergyWeb",
+            onSelect: function() {
+                network = libs.bitcoin.networks.bitcoin;
+                setHdCoin(246);
+            },
+          },
         {
             name: "EXCL - Exclusivecoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.exclusivecoin;
+                network = libs.bitcoin.networks.exclusivecoin;
                 setHdCoin(190);
             },
         },
         {
             name: "EXCC - ExchangeCoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.exchangecoin;
+                network = libs.bitcoin.networks.exchangecoin;
                 setHdCoin(0);
             },
         },
@@ -2239,140 +2733,160 @@
             name: "EXP - Expanse",
             segwitAvailable: false,
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.bitcoin;
+                network = libs.bitcoin.networks.bitcoin;
                 setHdCoin(40);
             },
         },
+        {
+            name: "FIO - Foundation for Interwallet Operability",
+            onSelect: function() {
+                network = libs.bitcoin.networks.bitcoin;
+                setHdCoin(235);
+            },
+        },
+        {
+            name: "FIRO - Firo (Zcoin rebrand)",
+            onSelect: function() {
+                network = libs.bitcoin.networks.firo;
+                setHdCoin(136);
+            },
+        },
         {
             name: "FIX - FIX",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.fix;
+                network = libs.bitcoin.networks.fix;
                 setHdCoin(336);
             },
         },
         {
             name: "FIX - FIX Testnet",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.fixtestnet;
+                network = libs.bitcoin.networks.fixtestnet;
                 setHdCoin(1);
             },
         },
         {
             name: "FJC - Fujicoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.fujicoin;
+                network = libs.bitcoin.networks.fujicoin;
                 setHdCoin(75);
             },
         },
         {
             name: "FLASH - Flashcoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.flashcoin;
+                network = libs.bitcoin.networks.flashcoin;
                 setHdCoin(120);
             },
         },
         {
             name: "FRST - Firstcoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.firstcoin;
+                network = libs.bitcoin.networks.firstcoin;
                 setHdCoin(167);
             },
         },
         {
             name: "FTC - Feathercoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.feathercoin;
+                network = libs.bitcoin.networks.feathercoin;
                 setHdCoin(8);
             },
         },
         {
             name: "GAME - GameCredits",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.game;
+                network = libs.bitcoin.networks.game;
                 setHdCoin(101);
             },
         },
         {
             name: "GBX - Gobyte",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.gobyte;
+                network = libs.bitcoin.networks.gobyte;
                 setHdCoin(176);
             },
         },
         {
             name: "GCR - GCRCoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.gcr;
+                network = libs.bitcoin.networks.gcr;
                 setHdCoin(79);
             },
         },
         {
             name: "GRC - Gridcoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.gridcoin;
+                network = libs.bitcoin.networks.gridcoin;
                 setHdCoin(84);
             },
         },
         {
             name: "GRS - Groestlcoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.groestlcoin;
+                network = libs.bitcoin.networks.groestlcoin;
                 setHdCoin(17);
             },
         },
         {
             name: "GRS - Groestlcoin Testnet",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.groestlcointestnet;
+                network = libs.bitcoin.networks.groestlcointestnet;
                 setHdCoin(1);
             },
         },
+        {
+            name: "HNS - Handshake",
+            onSelect: function() {
+                setHdCoin(5353);
+            },
+        },
         {
             name: "HNC - Helleniccoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.helleniccoin;
+                network = libs.bitcoin.networks.helleniccoin;
                 setHdCoin(168);
             },
         },
-		{
+        {
             name: "HUSH - Hush (Legacy)",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.hush;
+                network = libs.bitcoin.networks.hush;
                 setHdCoin(197);
             },
         },
-		{
+        {
             name: "HUSH - Hush3",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.hush3;
+                network = libs.bitcoin.networks.hush3;
                 setHdCoin(197);
             },
         },
         {
             name: "INSN - Insane",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.insane;
+                network = libs.bitcoin.networks.insane;
                 setHdCoin(68);
             },
         },
         {
             name: "IOP - Iop",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.iop;
+                network = libs.bitcoin.networks.iop;
                 setHdCoin(66);
             },
         },
         {
             name: "IXC - Ixcoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.ixcoin;
+                network = libs.bitcoin.networks.ixcoin;
                 setHdCoin(86);
             },
         },
         {
             name: "JBS - Jumbucks",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.jumbucks;
+                network = libs.bitcoin.networks.jumbucks;
                 setHdCoin(26);
             },
         },
@@ -2380,7 +2894,7 @@
             name: "KMD - Komodo",
             bip49available: false,
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.komodo;
+                network = libs.bitcoin.networks.komodo;
                 setHdCoin(141);
             },
         },
@@ -2388,35 +2902,35 @@
             name: "KOBO - Kobocoin",
             bip49available: false,
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.kobocoin;
+                network = libs.bitcoin.networks.kobocoin;
                 setHdCoin(196);
             },
         },
         {
             name: "LBC - Library Credits",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.lbry;
+                network = libs.bitcoin.networks.lbry;
                 setHdCoin(140);
             },
         },
         {
             name: "LCC - Litecoincash",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.litecoincash;
+                network = libs.bitcoin.networks.litecoincash;
                 setHdCoin(192);
             },
         },
         {
             name: "LDCN - Landcoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.landcoin;
+                network = libs.bitcoin.networks.landcoin;
                 setHdCoin(63);
             },
         },
         {
             name: "LINX - Linx",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.linx;
+                network = libs.bitcoin.networks.linx;
                 setHdCoin(114);
             },
         },
@@ -2424,14 +2938,14 @@
             name: "LKR - Lkrcoin",
             segwitAvailable: false,
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.lkrcoin;
+                network = libs.bitcoin.networks.lkrcoin;
                 setHdCoin(557);
             },
         },
         {
             name: "LTC - Litecoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.litecoin;
+                network = libs.bitcoin.networks.litecoin;
                 setHdCoin(2);
                 DOM.litecoinLtubContainer.removeClass("hidden");
             },
@@ -2439,7 +2953,7 @@
         {
             name: "LTCt - Litecoin Testnet",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.litecointestnet;
+                network = libs.bitcoin.networks.litecointestnet;
                 setHdCoin(1);
                 DOM.litecoinLtubContainer.removeClass("hidden");
             },
@@ -2447,28 +2961,28 @@
         {
             name: "LTZ - LitecoinZ",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.litecoinz;
+                network = libs.bitcoin.networks.litecoinz;
                 setHdCoin(221);
             },
         },
         {
             name: "LYNX - Lynx",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.lynx;
+                network = libs.bitcoin.networks.lynx;
                 setHdCoin(191);
             },
         },
         {
             name: "MAZA - Maza",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.maza;
+                network = libs.bitcoin.networks.maza;
                 setHdCoin(13);
             },
         },
         {
             name: "MEC - Megacoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.megacoin;
+                network = libs.bitcoin.networks.megacoin;
                 setHdCoin(217);
             },
         },
@@ -2476,162 +2990,177 @@
             name: "MIX - MIX",
             segwitAvailable: false,
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.bitcoin;
+                network = libs.bitcoin.networks.bitcoin;
                 setHdCoin(76);
             },
         },
         {
             name: "MNX - Minexcoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.minexcoin;
+                network = libs.bitcoin.networks.minexcoin;
                 setHdCoin(182);
             },
         },
         {
             name: "MONA - Monacoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.monacoin,
+                network = libs.bitcoin.networks.monacoin,
                 setHdCoin(22);
             },
         },
         {
             name: "MONK - Monkey Project",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.monkeyproject,
+                network = libs.bitcoin.networks.monkeyproject,
                 setHdCoin(214);
             },
         },
+        {
+            name: "MOAC - MOAC",
+            segwitAvailable: false,
+            onSelect: function() {
+                network = libs.bitcoin.networks.bitcoin;
+                setHdCoin(314);
+            },
+        },
         {
             name: "MUSIC - Musicoin",
             segwitAvailable: false,
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.bitcoin;
+                network = libs.bitcoin.networks.bitcoin;
                 setHdCoin(184);
             },
         },
+        {
+            name: "NANO - Nano",
+            onSelect: function() {
+                network = network = libs.nanoUtil.dummyNetwork;
+                setHdCoin(165);
+            },
+        },
         {
             name: "NAV - Navcoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.navcoin;
+                network = libs.bitcoin.networks.navcoin;
                 setHdCoin(130);
             },
         },
         {
             name: "NAS - Nebulas",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.bitcoin;
+                network = libs.bitcoin.networks.bitcoin;
                 setHdCoin(2718);
             },
         },
         {
             name: "NEBL - Neblio",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.neblio;
+                network = libs.bitcoin.networks.neblio;
                 setHdCoin(146);
             },
         },
         {
             name: "NEOS - Neoscoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.neoscoin;
+                network = libs.bitcoin.networks.neoscoin;
                 setHdCoin(25);
             },
         },
         {
             name: "NIX - NIX Platform",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.nix;
+                network = libs.bitcoin.networks.nix;
                 setHdCoin(400);
             },
         },
         {
             name: "NLG - Gulden",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.gulden;
+                network = libs.bitcoin.networks.gulden;
                 setHdCoin(87);
             },
         },
         {
             name: "NMC - Namecoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.namecoin;
+                network = libs.bitcoin.networks.namecoin;
                 setHdCoin(7);
             },
         },
         {
             name: "NRG - Energi",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.energi;
+                network = libs.bitcoin.networks.energi;
                 setHdCoin(204);
             },
         },
         {
             name: "NRO - Neurocoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.neurocoin;
+                network = libs.bitcoin.networks.neurocoin;
                 setHdCoin(110);
             },
         },
         {
             name: "NSR - Nushares",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.nushares;
+                network = libs.bitcoin.networks.nushares;
                 setHdCoin(11);
             },
         },
         {
             name: "NYC - Newyorkc",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.newyorkc;
+                network = libs.bitcoin.networks.newyorkc;
                 setHdCoin(179);
             },
         },
         {
             name: "NVC - Novacoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.novacoin;
+                network = libs.bitcoin.networks.novacoin;
                 setHdCoin(50);
             },
         },
         {
             name: "OK - Okcash",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.okcash;
+                network = libs.bitcoin.networks.okcash;
                 setHdCoin(69);
             },
         },
         {
             name: "OMNI - Omnicore",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.omnicore;
+                network = libs.bitcoin.networks.omnicore;
                 setHdCoin(200);
             },
         },
         {
             name: "ONION - DeepOnion",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.deeponion;
+                network = libs.bitcoin.networks.deeponion;
                 setHdCoin(305);
             },
         },
         {
             name: "ONX - Onixcoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.onixcoin;
+                network = libs.bitcoin.networks.onixcoin;
                 setHdCoin(174);
             },
         },
-		{
+        {
             name: "PHR - Phore",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.phore;
+                network = libs.bitcoin.networks.phore;
                 setHdCoin(444);
             },
         },
         {
             name: "PINK - Pinkcoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.pinkcoin;
+                network = libs.bitcoin.networks.pinkcoin;
                 setHdCoin(117);
             },
         },
@@ -2639,21 +3168,21 @@
             name: "PIRL - Pirl",
             segwitAvailable: false,
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.bitcoin;
+                network = libs.bitcoin.networks.bitcoin;
                 setHdCoin(164);
             },
         },
         {
             name: "PIVX - PIVX",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.pivx;
+                network = libs.bitcoin.networks.pivx;
                 setHdCoin(119);
             },
         },
         {
             name: "PIVX - PIVX Testnet",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.pivxtestnet;
+                network = libs.bitcoin.networks.pivxtestnet;
                 setHdCoin(1);
             },
         },
@@ -2661,126 +3190,154 @@
             name: "POA - Poa",
             segwitAvailable: false,
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.bitcoin;
+                network = libs.bitcoin.networks.bitcoin;
                 setHdCoin(178);
             },
         },
         {
             name: "POSW - POSWcoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.poswcoin;
+                network = libs.bitcoin.networks.poswcoin;
                 setHdCoin(47);
             },
         },
         {
             name: "POT - Potcoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.potcoin;
+                network = libs.bitcoin.networks.potcoin;
                 setHdCoin(81);
             },
         },
         {
             name: "PPC - Peercoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.peercoin;
+                network = libs.bitcoin.networks.peercoin;
                 setHdCoin(6);
             },
         },
-		{
+        {
             name: "PRJ - ProjectCoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.projectcoin;
+                network = libs.bitcoin.networks.projectcoin;
                 setHdCoin(533);
             },
         },
         {
             name: "PSB - Pesobit",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.pesobit;
+                network = libs.bitcoin.networks.pesobit;
                 setHdCoin(62);
             },
         },
         {
             name: "PUT - Putincoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.putincoin;
+                network = libs.bitcoin.networks.putincoin;
                 setHdCoin(122);
             },
         },
         {
             name: "RPD - Rapids",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.rapids;
+                network = libs.bitcoin.networks.rapids;
                 setHdCoin(320);
             },
         },
         {
             name: "RVN - Ravencoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.ravencoin;
+                network = libs.bitcoin.networks.ravencoin;
                 setHdCoin(175);
             },
         },
+        {
+            name: "R-BTC - RSK",
+            onSelect: function() {
+                network = libs.bitcoin.networks.rsk;
+                setHdCoin(137);
+            },
+        },
+        {
+            name: "tR-BTC - RSK Testnet",
+            onSelect: function() {
+                network = libs.bitcoin.networks.rsktestnet;
+                setHdCoin(37310);
+            },
+        },
         {
             name: "RBY - Rubycoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.rubycoin;
+                network = libs.bitcoin.networks.rubycoin;
                 setHdCoin(16);
             },
         },
         {
             name: "RDD - Reddcoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.reddcoin;
+                network = libs.bitcoin.networks.reddcoin;
                 setHdCoin(4);
             },
         },
+        {
+            name: "RITO - Ritocoin",
+            onSelect: function() {
+                network = libs.bitcoin.networks.ritocoin;
+                setHdCoin(19169);
+            },
+        },
         {
             name: "RVR - RevolutionVR",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.revolutionvr;
+                network = libs.bitcoin.networks.revolutionvr;
                 setHdCoin(129);
             },
         },
         {
           name: "SAFE - Safecoin",
           onSelect: function() {
-              network = bitcoinjs.bitcoin.networks.safecoin;
+              network = libs.bitcoin.networks.safecoin;
               setHdCoin(19165);
             },
         },
-	{
+        {
+            name: "SCRIBE - Scribe",
+            onSelect: function() {
+                network = libs.bitcoin.networks.scribe;
+                setHdCoin(545);
+            },
+        },
+    {
           name: "SLS - Salus",
           onSelect: function() {
-              network = bitcoinjs.bitcoin.networks.salus;
+              network = libs.bitcoin.networks.salus;
               setHdCoin(63);
             },
         },
         {
             name: "SDC - ShadowCash",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.shadow;
+                network = libs.bitcoin.networks.shadow;
                 setHdCoin(35);
             },
         },
         {
             name: "SDC - ShadowCash Testnet",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.shadowtn;
+                network = libs.bitcoin.networks.shadowtn;
                 setHdCoin(1);
             },
         },
         {
             name: "SLM - Slimcoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.slimcoin;
+                network = libs.bitcoin.networks.slimcoin;
                 setHdCoin(63);
             },
         },
         {
             name: "SLM - Slimcoin Testnet",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.slimcointn;
+                network = libs.bitcoin.networks.slimcointn;
                 setHdCoin(111);
             },
         },
@@ -2794,203 +3351,237 @@
         {
             name: "SLR - Solarcoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.solarcoin;
+                network = libs.bitcoin.networks.solarcoin;
                 setHdCoin(58);
             },
         },
         {
             name: "SMLY - Smileycoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.smileycoin;
+                network = libs.bitcoin.networks.smileycoin;
                 setHdCoin(59);
             },
         },
         {
             name: "STASH - Stash",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.stash;
+                network = libs.bitcoin.networks.stash;
                 setHdCoin(0xC0C0);
             },
         },
         {
             name: "STASH - Stash Testnet",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.stashtn;
+                network = libs.bitcoin.networks.stashtn;
                 setHdCoin(0xCAFE);
             },
         },
         {
             name: "STRAT - Stratis",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.stratis;
+                network = libs.bitcoin.networks.stratis;
                 setHdCoin(105);
             },
         },
+        {
+            name: "SUGAR - Sugarchain",
+            onSelect: function() {
+                network = libs.bitcoin.networks.sugarchain;
+                setHdCoin(408);
+            },
+        },
+        {
+            name: "TUGAR - Sugarchain Testnet",
+            onSelect: function() {
+                network = libs.bitcoin.networks.sugarchaintestnet;
+                setHdCoin(408);
+            },
+        },
+        {
+            name: "SWTC - Jingtum",
+            onSelect: function() {
+                network = libs.bitcoin.networks.bitcoin;
+                setHdCoin(315);
+            },
+        },
         {
             name: "TSTRAT - Stratis Testnet",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.stratistest;
+                network = libs.bitcoin.networks.stratistest;
                 setHdCoin(105);
             },
         },
         {
             name: "SYS - Syscoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.syscoin;
+                network = libs.bitcoin.networks.syscoin;
                 setHdCoin(57);
             },
         },
         {
             name: "THC - Hempcoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.hempcoin;
+                network = libs.bitcoin.networks.hempcoin;
                 setHdCoin(113);
             },
         },
+        {
+            name: "THT - Thought",
+            onSelect: function() {
+                network = libs.bitcoin.networks.thought;
+                setHdCoin(1618);
+            },
+        },
         {
             name: "TOA - Toa",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.toa;
+                network = libs.bitcoin.networks.toa;
                 setHdCoin(159);
             },
         },
+        {
+            name: "TRX - Tron",
+            onSelect: function() {
+                setHdCoin(195);
+            },
+        },
         {
             name: "TWINS - TWINS",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.twins;
+                network = libs.bitcoin.networks.twins;
                 setHdCoin(970);
             },
         },
         {
             name: "TWINS - TWINS Testnet",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.twinstestnet;
+                network = libs.bitcoin.networks.twinstestnet;
                 setHdCoin(1);
             },
         },
         {
             name: "USC - Ultimatesecurecash",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.ultimatesecurecash;
+                network = libs.bitcoin.networks.ultimatesecurecash;
                 setHdCoin(112);
             },
         },
         {
             name: "USNBT - NuBits",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.nubits;
+                network = libs.bitcoin.networks.nubits;
                 setHdCoin(12);
             },
         },
         {
             name: "UNO - Unobtanium",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.unobtanium;
+                network = libs.bitcoin.networks.unobtanium;
                 setHdCoin(92);
             },
         },
         {
             name: "VASH - Vpncoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.vpncoin;
+                network = libs.bitcoin.networks.vpncoin;
                 setHdCoin(33);
             },
         },
         {
             name: "VET - VeChain",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.bitcoin;
+                network = libs.bitcoin.networks.bitcoin;
                 setHdCoin(818);
             },
         },
         {
             name: "VIA - Viacoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.viacoin;
+                network = libs.bitcoin.networks.viacoin;
                 setHdCoin(14);
             },
         },
         {
             name: "VIA - Viacoin Testnet",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.viacointestnet;
+                network = libs.bitcoin.networks.viacointestnet;
                 setHdCoin(1);
             },
         },
         {
             name: "VIVO - Vivo",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.vivo;
+                network = libs.bitcoin.networks.vivo;
                 setHdCoin(166);
             },
         },
         {
             name: "VTC - Vertcoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.vertcoin;
+                network = libs.bitcoin.networks.vertcoin;
                 setHdCoin(28);
             },
         },
         {
             name: "WGR - Wagerr",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.wagerr;
+                network = libs.bitcoin.networks.wagerr;
                 setHdCoin(7825266);
             },
         },
         {
             name: "WC - Wincoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.wincoin;
+                network = libs.bitcoin.networks.wincoin;
                 setHdCoin(181);
             },
         },
-		{
+        {
             name: "XAX - Artax",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.artax;
+                network = libs.bitcoin.networks.artax;
                 setHdCoin(219);
             },
         },
         {
             name: "XBC - Bitcoinplus",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.bitcoinplus;
+                network = libs.bitcoin.networks.bitcoinplus;
                 setHdCoin(65);
             },
         },
         {
             name: "XLM - Stellar",
             onSelect: function() {
-                network = stellarUtil.dummyNetwork;
+                network = libs.stellarUtil.dummyNetwork;
                 setHdCoin(148);
             },
         },
         {
             name: "XMY - Myriadcoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.myriadcoin;
+                network = libs.bitcoin.networks.myriadcoin;
                 setHdCoin(90);
             },
         },
         {
             name: "XRP - Ripple",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.bitcoin;
+                network = libs.bitcoin.networks.bitcoin;
                 setHdCoin(144);
             },
         },
         {
             name: "XVC - Vcash",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.vcash;
+                network = libs.bitcoin.networks.vcash;
                 setHdCoin(127);
             },
         },
         {
             name: "XVG - Verge",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.verge;
+                network = libs.bitcoin.networks.verge;
                 setHdCoin(77);
             },
         },
@@ -2998,42 +3589,49 @@
             name: "XUEZ - Xuez",
             segwitAvailable: false,
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.xuez;
+                network = libs.bitcoin.networks.xuez;
                 setHdCoin(225);
             },
         },
         {
             name: "XWC - Whitecoin",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.whitecoin;
+                network = libs.bitcoin.networks.whitecoin;
                 setHdCoin(155);
             },
         },
         {
-            name: "XZC - Zcoin",
+            name: "XZC - Zcoin (rebranded to Firo)",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.zcoin;
+                network = libs.bitcoin.networks.zcoin;
                 setHdCoin(136);
             },
         },
+        {
+            name: "ZBC - ZooBlockchain",
+            onSelect: function () {
+            network = libs.bitcoin.networks.zoobc;
+            setHdCoin(883);
+            },
+        },
         {
             name: "ZCL - Zclassic",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.zclassic;
+                network = libs.bitcoin.networks.zclassic;
                 setHdCoin(147);
             },
         },
         {
             name: "ZEC - Zcash",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.zcash;
+                network = libs.bitcoin.networks.zcash;
                 setHdCoin(133);
             },
         },
         {
             name: "ZEN - Horizen",
             onSelect: function() {
-                network = bitcoinjs.bitcoin.networks.zencash;
+                network = libs.bitcoin.networks.zencash;
                 setHdCoin(121);
             },
         },
@@ -3070,6 +3668,96 @@
         }
     ]
 
+    // RSK - RSK functions - begin
+    function stripHexPrefix(address) {
+        if (typeof address !== "string") {
+            throw new Error("address parameter should be a string.");
+        }
+
+        var hasPrefix = (address.substring(0, 2) === "0x" ||
+            address.substring(0, 2) === "0X");
+
+        return hasPrefix ? address.slice(2) : address;
+    };
+
+    function toChecksumAddressForRsk(address, chainId = null) {
+        if (typeof address !== "string") {
+            throw new Error("address parameter should be a string.");
+        }
+
+        if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) {
+            throw new Error("Given address is not a valid RSK address: " + address);
+        }
+
+        var stripAddress = stripHexPrefix(address).toLowerCase();
+        var prefix = chainId != null ? chainId.toString() + "0x" : "";
+        var keccakHash = libs.ethUtil.keccak256(prefix + stripAddress)
+            .toString("hex")
+            .replace(/^0x/i, "");
+        var checksumAddress = "0x";
+
+        for (var i = 0; i < stripAddress.length; i++) {
+            checksumAddress +=
+                parseInt(keccakHash[i], 16) >= 8 ?
+                stripAddress[i].toUpperCase() :
+                stripAddress[i];
+        }
+
+        return checksumAddress;
+    }
+
+    // RSK - RSK functions - end
+
+    // ELA - Elastos functions - begin
+    function displayBip44InfoForELA() {
+        if (!isELA()) {
+            return;
+        }
+
+        var coin = parseIntNoNaN(DOM.bip44coin.val(), 0);
+        var account = parseIntNoNaN(DOM.bip44account.val(), 0);
+
+        // Calculate the account extended keys
+        var accountXprv = libs.elastosjs.getAccountExtendedPrivateKey(seed, coin, account);
+        var accountXpub = libs.elastosjs.getAccountExtendedPublicKey(seed, coin, account);
+
+        // Display the extended keys
+        DOM.bip44accountXprv.val(accountXprv);
+        DOM.bip44accountXpub.val(accountXpub);
+    }
+
+    function displayBip32InfoForELA() {
+        if (!isELA()) {
+            return;
+        }
+
+        var coin = parseIntNoNaN(DOM.bip44coin.val(), 0);
+        var account = parseIntNoNaN(DOM.bip44account.val(), 0);
+        var change = parseIntNoNaN(DOM.bip44change.val(), 0);
+
+        DOM.extendedPrivKey.val(libs.elastosjs.getBip32ExtendedPrivateKey(seed, coin, account, change));
+        DOM.extendedPubKey.val(libs.elastosjs.getBip32ExtendedPublicKey(seed, coin, account, change));
+
+        // Display the addresses and privkeys
+        clearAddressesList();
+        var initialAddressCount = parseInt(DOM.rowsToAdd.val());
+        displayAddresses(0, initialAddressCount);
+    }
+
+    function calcAddressForELA(seed, coin, account, change, index) {
+        if (!isELA()) {
+            return;
+        }
+
+        var publicKey = libs.elastosjs.getDerivedPublicKey(libs.elastosjs.getMasterPublicKey(seed), change, index);
+        return {
+            privateKey: libs.elastosjs.getDerivedPrivateKey(seed, coin, account, change, index),
+            publicKey: publicKey,
+            address: libs.elastosjs.getAddress(publicKey.toString('hex'))
+        };
+    }
+    // ELA - Elastos functions - end
+
     init();
 
 })();