Browse Source

documentation: MMGen -> MMGen Wallet

The MMGen Project 1 year ago
parent
commit
b9a443fe8a

+ 55 - 54
README.md

@@ -7,11 +7,11 @@
 
 ### Description
 
-MMGen is a wallet and cold storage solution for Bitcoin (and selected altcoins)
-implemented as a suite of lightweight Python scripts.  The scripts work in
-tandem with a reference Bitcoin or altcoin daemon running on both online and
-offline computers to provide a robust solution for securely storing, tracking,
-sending and receiving your crypto assets.
+MMGen Wallet is a wallet and cold storage solution for Bitcoin (and selected
+altcoins) implemented as a suite of lightweight Python scripts.  The scripts
+work in tandem with a reference Bitcoin or altcoin daemon running on both online
+and offline computers to provide a robust solution for securely storing,
+tracking, sending and receiving your crypto assets.
 
 The online computer is used for tracking balances and creating and sending
 transactions, while the offline machine (typically an air-gapped, low-power
@@ -20,17 +20,17 @@ and transaction signing.  All operations involving secret data are handled
 offline: **your seed and private keys never come into contact with a
 network-connected device.**
 
-MMGen is designed for reliability by having the reference Bitcoin or altcoin
-daemon, rather than less-tested third-party software, do all the “heavy lifting”
-of tracking and signing transactions.  It’s also designed with privacy in mind:
-unlike some other online/offline wallets, MMGen is a completely self-contained
-system that makes **no connections to the Internet** apart from the coin network
-itself: no information about which addresses you’re tracking is ever leaked to
-the outside world.
+MMGen Wallet is designed for reliability by having the reference Bitcoin or
+altcoin daemon, rather than less-tested third-party software, do all the “heavy
+lifting” of tracking and signing transactions.  It’s also designed with privacy
+in mind: unlike some other online/offline wallets, MMGen Wallet is a completely
+self-contained system that makes **no connections to the Internet** apart from
+the coin network itself: no information about which addresses you’re tracking is
+ever leaked to the outside world.
 
-Like all deterministic wallets, MMGen can generate a virtually unlimited number
-of address/key pairs from a single seed.  Your wallet never changes, so you need
-back it up only once.
+Like all deterministic wallets, MMGen Wallet can generate a virtually unlimited
+number of address/key pairs from a single seed.  Your wallet never changes, so
+you need back it up only once.
 
 At the heart of the MMGen system is the seed, the “master key” providing access
 to all your crypto assets.  The seed can be stored in many different formats:
@@ -45,18 +45,18 @@ all formats is supported.
 
 #### Simplified key derivation and seed-phrase generation
 
-To deterministically derive its keys, MMGen uses a non-hierarchical scheme
-differing from the BIP32 protocol on which most of today’s popular wallets are
-based.  One advantage of this simple, hash-based scheme is that you can easily
-[recover your private keys from your seed without the MMGen program itself][K]
-using standard command-line utilities.
+To deterministically derive its keys, MMGen Wallet uses a non-hierarchical
+scheme differing from the BIP32 protocol on which most of today’s popular
+wallets are based.  One advantage of this simple, hash-based scheme is that you
+can easily [recover your private keys from your seed without the MMGen Wallet
+software][K] using standard command-line utilities.
 
-MMGen also differs from most cryptocurrency wallets today in its use of the
-original 1626-word [Electrum wordlist][ew] for mnemonic seed phrases.  Seed
+MMGen Wallet also differs from most cryptocurrency wallets today in its use of
+the original 1626-word [Electrum wordlist][ew] for mnemonic seed phrases.  Seed
 phrases are derived using ordinary base conversion, similarly allowing you to
-regenerate your seed from your seed phrase without MMGen program itself should
-the need arise.  An example of how to do this at the Python prompt is provided
-[here.][S]
+regenerate your seed from your seed phrase without the MMGen Wallet software
+should the need arise.  An example of how to do this at the Python prompt is
+provided [here.][S]
 
 The original Electrum wordlist was derived from a [frequency list][fl] of words
 found in contemporary English poetry.  The high emotional impact of these words
@@ -64,10 +64,10 @@ makes seed phrases easy to memorize.  Curiously, only 861 of them are shared by
 the more prosaic 2048-word [BIP39 wordlist][bw] used in most wallets today.
 
 Beginning with version 0.12.0, the BIP39 mnemonic format is also supported,
-allowing you to use MMGen as a master wallet for other wallets supporting that
-widespread standard.
+allowing you to use MMGen Wallet as a master wallet for other wallets supporting
+that widespread standard.
 
-#### A brief overview of MMGen’s unique feature set:
+#### A brief overview of MMGen Wallet’s unique feature set:
 
 - **[Full transaction and address tracking support][T]** for Bitcoin, [Bcash][bx],
   [Litecoin][bx], [Ethereum][E], Ethereum Classic and [ERC20 tokens][E].
@@ -106,10 +106,10 @@ widespread standard.
   machine into “hands-off” mode, allowing you to transact directly from cold
   storage securely and conveniently.  Additional LED signaling support is
   provided for Raspbian and Armbian platforms.
-- **[Password generation][G]:** MMGen can be used to generate and manage your
-  online passwords.  Password lists are identified by arbitrarily chosen strings
-  like “alice@github” or “bob@reddit”.  Passwords of different lengths and
-  formats, including BIP39, are supported.
+- **[Password generation][G]:** MMGen Wallet can be used to generate and manage
+  your online passwords.  Password lists are identified by arbitrarily chosen
+  strings like “alice@github” or “bob@reddit”.  Passwords of different lengths
+  and formats, including BIP39, are supported.
 - **[Message signing][MS]** for BTC, BCH, LTC, ETH and ETC.  Signing for
   multiple addresses and autosigning are supported.
 - **Selectable seed lengths** of 128, 192 or 256 bits.  Subwallets may have
@@ -120,19 +120,20 @@ widespread standard.
 - **Wallet-free operation:** All wallet operations can be performed directly
   from your seed phrase at the prompt, allowing you to dispense with a
   physically stored wallet entirely if you wish.
-- Word-completing **mnemonic entry modes** customized for each of MMGen’s
+- Word-completing **mnemonic entry modes** customized for each of MMGen Wallet’s
   supported wordlists minimize keystrokes required during seed phrase entry.
 - **Stealth mnemonic entry:** This feature allows you to obfuscate your seed
   phrase with “dead” keystrokes to guard against acoustic side-channel attacks.
-- **Network privacy:** MMGen never “calls home” or checks for upgrades over the
-  network.  No information about your wallet installation or crypto assets is
-  ever leaked to third parties.
-- **Human-readable wallet files:** All of MMGen’s wallet formats, with the
-  exception of incognito wallets, can be printed or copied by hand.
-- **Terminal-based:** MMGen can be run in a screen or tmux session on your local
-  network.
-- **Scriptability:** Most MMGen commands can be made non-interactive, allowing
-  you to automate repetitive tasks using shell scripts.
+- **Network privacy:** MMGen Wallet never “calls home” or checks for upgrades
+  over the network.  No information about your wallet installation or crypto
+  assets is ever leaked to third parties.
+- **Human-readable wallet files:** All of MMGen Wallet’s wallet formats, with
+  the exception of incognito wallets, can be printed or copied by hand.
+- **Terminal-based:** MMGen Wallet can be run in a screen or tmux session on
+  your local network.
+- **Scriptability:** Most of MMGen Wallet’s commands can be made
+  non-interactive, allowing you to automate repetitive tasks using shell
+  scripts.
 - The project also includes the [`mmgen-tool`][L] utility, a handy “pocket
   knife” for cryptocurrency developers, along with an easy-to-use [**tool API
   interface**][ta] providing access to a subset of its commands from within
@@ -149,15 +150,15 @@ Linux, Armbian, Raspbian, Windows/MSYS2
 > #### [Install from source on Debian, Ubuntu, Raspbian, Armbian or Arch Linux][2]
 
 
-### Using MMGen
+### Using MMGen Wallet
 
-> #### [Getting Started with MMGen][3]
+> #### [Getting Started with MMGen Wallet][3]
 
-> #### [MMGen Quick Start with Regtest Mode][Q]
+> #### [MMGen Wallet Quick Start with Regtest Mode][Q]
 
-> #### [MMGen command help][6]
+> #### [MMGen Wallet command help][6]
 
-> #### [Recovering your keys without the MMGen software][K]
+> #### [Recovering your keys without the MMGen Wallet software][K]
 
 > #### [Altcoin and Forkcoin support (ETH,ETC,XMR,ZEC,LTC,BCH and 144 Bitcoin-derived alts)][F]
 
@@ -192,15 +193,15 @@ Donate:
  ⊙ BCH: *15TLdmi5NYLdqmtCqczUs5pBPkJDXRs83w*    
  ⊙ XMR: *8B14zb8wgLuKDdse5p8f3aKpFqRdB4i4xj83b7BHYABHMvHifWxiDXeKRELnaxL5FySfeRRS5girgUvgy8fQKsYMEzPUJ8h*
 
-[1]:  ../../wiki/Install-MMGen-on-Microsoft-Windows
-[2]:  ../../wiki/Install-MMGen-on-Linux
-[3]:  ../../wiki/Getting-Started-with-MMGen
+[1]:  ../../wiki/Install-MMGen-Wallet-on-Microsoft-Windows
+[2]:  ../../wiki/Install-MMGen-Wallet-on-Linux
+[3]:  ../../wiki/Getting-Started-with-MMGen-Wallet
 [5]:  ../../wiki/MMGen-Signing-Keys
 [6]:  ../../wiki/MMGen-command-help
 [7]:  http://bitcoinmagazine.com/8396/deterministic-wallets-advantages-flaw/
 [8]:  https://github.com/mmgen/MMGenLive
 [9]:  https://mmgen.org/images/rxvt-txcreate.jpg
-[Q]:  ../../wiki/MMGen-Quick-Start-with-Regtest-Mode
+[Q]:  ../../wiki/MMGen-Wallet-Quick-Start-with-Regtest-Mode
 [K]:  ../../wiki/Recovering-Your-Keys-Without-the-MMGen-Software
 [S]:  ../../wiki/Recovering-Your-Keys-Without-the-MMGen-Software#a_mh
 [F]:  ../../wiki/Altcoin-and-Forkcoin-Support
@@ -213,15 +214,15 @@ Donate:
 [xm]: ../../wiki/xmrwallet-[MMGen-command-help]
 [G]:  ../../wiki/passgen-[MMGen-command-help]
 [MS]: ../../wiki/msg-[MMGen-command-help]
-[T]:  ../../wiki/Getting-Started-with-MMGen#a_ct
+[T]:  ../../wiki/Getting-Started-with-MMGen-Wallet#a_ct
 [E]:  ../../wiki/Altcoin-and-Forkcoin-Support#a_tx
 [ag]: ../../wiki/addrgen-[MMGen-command-help]
 [bx]: ../../wiki/Altcoin-and-Forkcoin-Support#a_bch
 [mx]: ../../wiki/Altcoin-and-Forkcoin-Support#a_xmr
 [zx]: ../../wiki/Altcoin-and-Forkcoin-Support#a_zec
 [ax]: ../../wiki/Altcoin-and-Forkcoin-Support#a_kg
-[M]:  ../../wiki/Getting-Started-with-MMGen#a_fee
-[R]:  ../../wiki/Getting-Started-with-MMGen#a_rbf
+[M]:  ../../wiki/Getting-Started-with-MMGen-Wallet#a_fee
+[R]:  ../../wiki/Getting-Started-with-MMGen-Wallet#a_rbf
 [B]:  ../../wiki/txbump-[MMGen-command-help]
 [69]: https://github.com/bitcoin/bips/blob/master/bip-0069.mediawiki
 [O]:  ../../wiki/XOR-Seed-Splitting:-Theory-and-Practice

+ 0 - 5
doc/README.mswin.md

@@ -1,5 +0,0 @@
-### MMGen MS Windows Notes
-
-The following MMGen features are unsupported on the MSWin/MinGW platform:
-
-- Autosign

+ 6 - 5
doc/wiki/install-linux/Install-Bitcoind-from-Source-on-Debian-or-Ubuntu-Linux.md → doc/wiki/install-linux/Install-Bitcoind-from-Source-on-Linux.md

@@ -5,17 +5,18 @@ binaries are available for Bitcoin Core, Bitcoin ABC and Litecoin.  See the
 
 ### Install dependencies:
 
-> Make sure the required boost library development packages are installed:
+> Make sure the required development packages are installed:
+
+Debian/Ubuntu:
 
 ```text
-sudo apt-get install libboost-system-dev libboost-filesystem-dev libboost-program-options-dev libboost-chrono-dev libboost-test-dev libboost-thread-dev
+sudo apt-get install build-essential libtool autotools-dev autoconf pkg-config libssl-dev libdb-dev libdb++-dev libevent-dev libboost-system-dev libboost-filesystem-dev libboost-program-options-dev libboost-chrono-dev libboost-test-dev libboost-thread-dev
 ```
 
-> You’ll also need the following standard dependencies, if they’re not already on
-> your system:
+ArchLinux:
 
 ```text
-sudo apt-get install build-essential libtool autotools-dev autoconf pkg-config libssl-dev libdb-dev libdb++-dev libevent-dev
+pacman --sync --needed autoconf automake boost gcc git libevent libtool make pkgconf python sqlite
 ```
 
 ### Compile and install Bitcoin Core:

+ 3 - 3
doc/wiki/install-linux/Install-Bitcoind.md

@@ -83,7 +83,7 @@ $ bitcoind
 
 # Bitcoin Cash Node:
 $ mkdir $APPDATA/Bitcoin-Cash-Node
-$ bitcoind-bchn --listen=0 --rpcport=8442 --datadir=$APPDATA/Bitcoin-Cash-Node --usecashaddr=0
+$ bitcoind-bchn --listen=0 --rpcport=8432 --datadir=$APPDATA/Bitcoin-Cash-Node --usecashaddr=0
 
 # Litecoin
 $ litecoind
@@ -102,7 +102,7 @@ $ bitcoind --daemon
 
 # Bitcoin Cash Node:
 $ mkdir ~/.bitcoin-bchn
-$ bitcoind-bchn --daemon --listen=0 --rpcport=8442 --datadir=$HOME/.bitcoin-bchn --usecashaddr=0
+$ bitcoind-bchn --daemon --listen=0 --rpcport=8432 --datadir=$HOME/.bitcoin-bchn --usecashaddr=0
 
 # Litecoin:
 $ litecoind --daemon
@@ -115,7 +115,7 @@ $ litecoind --daemon
 $ bitcoin-cli help
 
 # Bitcoin Cash Node:
-$ bitcoin-cli-bchn --rpcport=8442 help
+$ bitcoin-cli-bchn --rpcport=8432 help
 
 # Litecoin:
 $ litecoin-cli help

+ 105 - 0
doc/wiki/install-linux/Install-MMGen-Wallet-on-Linux.md

@@ -0,0 +1,105 @@
+*NOTE: the instructions on this page are for a Bitcoin-only setup.  For
+altcoin support, additional installation steps are required.  See*
+[**Altcoin and Forkcoin Support**][af] *for more information.*
+
+### Perform the following steps on both your online and offline computers:
+
+For computers with no Internet connection, see **Note for offline machines** below.
+
+### Install required packages from your Linux distribution:
+
+#### Debian/Ubuntu:
+
+```text
+$ sudo apt-get install curl git gcc libtool make autoconf libgmp-dev libssl-dev libpcre3-dev libmpfr-dev libmpc-dev python3-dev python3-pip libsecp256k1-dev
+```
+
+#### Arch Linux:
+
+```text
+$ sudo pacman -S curl git gcc libtool make autoconf automake autogen pcre python-pip libsecp256k1
+```
+
+To keep your MMGen Wallet installation isolated from the rest of your Python
+packages, you may wish to use a [virtual environment][ve].  If you choose not to
+do this, you may get an ‘externally-managed-environment’ error when installing
+packages with `pip`.  In this case, you must add `--break-system-packages`
+to the `pip` command line.  Note that this will not in fact break any system
+packages, as pip installs all packages under the user’s home directory when
+invoked as user.
+
+### Upgrade the Python build tools:
+
+```text
+$ python3 -m pip install --upgrade pip setuptools build wheel
+```
+
+### Install MMGen:
+
+#### Stable version:
+
+```text
+$ python3 -m pip install mmgen-wallet
+```
+
+#### Development version:
+
+**Note:** While the development version is always tested on Linux before being
+pushed to the public repository, security vulnerabilities are more likely to be
+present in new code than in a stable release.  In addition, new code may require
+dependencies or installation steps not yet covered in the documentation.
+
+If not running in a virtual environment, make sure that `~/.local/bin` is in
+`PATH`.  Existing MMGen Wallet users should delete any old installations under
+`/usr` or `/usr/local`.
+
+```text
+$ git clone https://github.com/mmgen/mmgen.git
+$ cd mmgen
+$ python3 -m build --no-isolation
+$ python3 -m pip install --upgrade dist/*.whl # see 'Install Note' below
+$ cd ..
+```
+
+**Install Note:** When upgrading from previous versions, the `--force` and
+`--no-deps` options also come in handy on occasion.
+
+Install your coin daemon(s).  To install prebuilt binaries, go [here][01].  To
+install from source, go [here][02].
+
+If you plan to run the test suite, additional installation steps are required.
+Refer to the [Test Suite][ts] wiki page for details.
+
+#### Note for offline machines:
+
+The computer you’ve designated for offline use must be connected to the
+Internet to retrieve and install the above packages as described above.  This
+is normally not a problem, as you can simply take it offline permanently after
+the install is done, preferably removing or disabling its network interfaces.
+
+However, if your machine is already offline and you wish to leave it that way,
+or if it lacks a network interface entirely, then you’ll need to take the
+following steps:
+
+> If your offline and offline computers have the same architecture, then
+> download the Debian/Ubuntu packages and their dependencies on the online
+> one using `apt-get download`.  Otherwise, retrieve the packages manually
+> from `packages.debian.org` or `packages.ubuntu.com`.
+>
+> Download the Python build tools using `python3 -m pip download`.
+>
+> Transfer the downloaded files to your offline computer using a USB stick or
+> other removable medium.  Install the Debian/Ubuntu packages with `sudo dpkg
+> -i` and the Python packages with `python3 -m pip install`.
+
+Congratulations, your installation is now complete!  You can now proceed to
+[**Getting Started with MMGen**][gs].
+
+[01]: Install-Bitcoind
+[02]: Install-Bitcoind-from-Source-on-Linux
+[ts]: Test-Suite
+[gs]: Getting-Started-with-MMGen-Wallet
+[pi]: https://pypi.org
+[af]: Altcoin-and-Forkcoin-Support
+[ec]: https://github.com/bitcoin-core/secp256k1.git
+[ve]: https://docs.python.org/3/library/venv.html

+ 0 - 107
doc/wiki/install-linux/Install-MMGen-on-Linux.md

@@ -1,107 +0,0 @@
-*NOTE: the instructions on this page are for a Bitcoin-only setup.  For
-altcoin support, additional installation steps are required.  See*
-[**Altcoin and Forkcoin Support**][af] *for more information.*
-
-### Perform the following steps on both your online and offline computers:
-
-For computers with no Internet connection, see **Note for offline machines** below.
-
-#### Install required packages:
-
-##### Debian/Ubuntu:
-
-```text
-$ sudo apt-get install curl git gcc libtool make autoconf libgmp-dev libssl-dev libpcre3-dev libmpfr-dev libmpc-dev python3-dev python3-pip
-```
-
-##### Arch Linux:
-
-```text
-$ sudo pacman -S curl git gcc libtool make autoconf automake autogen pcre python-pip
-```
-
-#### Upgrade the build tools:
-
-```text
-$ python3 -m pip install --user --upgrade pip setuptools build wheel
-```
-
-If you get an ‘externally-managed-environment’ error (with Debian bookworm,
-for example), add `--break-system-packages` to the command line.  Note that this
-will not in fact break any system packages, as pip installs all packages under
-the user’s home directory when `--user` is in effect.
-
-#### Install MMGen:
-
-Make sure that `~/.local/bin` is in `PATH`.  Existing MMGen users should delete
-any old installations under `/usr` or `/usr/local`.
-
-```text
-$ git clone https://github.com/mmgen/mmgen.git
-$ cd mmgen
-$ git checkout stable_linux # see 'Note' below
-$ python3 -m build --no-isolation
-$ python3 -m pip install --user --upgrade dist/*.whl # see 'Install Note' below
-$ cd ..
-```
-
-**Note:** if you want to use features that have appeared since the latest
-`stable_linux` release, then you can omit the `git checkout` step and remain on
-the `master` branch.  Please bear in mind, however, that while the tip of
-`master` is always tested on Linux before being pushed to the public repository,
-security vulnerabilities are more likely to be present in new code than in a
-stable release.  In addition, new code may require dependencies or installation
-steps not yet covered in the documentation.
-
-**Install Note:** The `--force` and `--no-deps` options also come in handy
-on occasion.
-
-If you plan to run the test suite, additional installation steps are required.
-Refer to the [Test Suite][ts] wiki page for details.
-
-Install your coin daemon(s).  To install prebuilt binaries, go [here][01].  To
-install from source, go [here][02].
-
-##### Note for offline machines:
-
-The computer you’ve designated for offline use must be connected to the
-Internet to retrieve and install the above packages as described above.  This
-is normally not a problem, as you can simply take it offline permanently after
-the install is done, preferably removing or disabling its network interfaces.
-
-However, if your machine is already offline and you wish to leave it that way,
-or if it lacks a network interface entirely, then you’ll need to take roughly
-the following steps:
-
-> If your offline and offline computers have the same architecture, then
-> download the Debian/Ubuntu packages and their dependencies on the online
-> one using `apt-get download`.  Otherwise, retrieve the packages manually
-> from `packages.debian.org` or `packages.ubuntu.com`.
->
-> Download any required Python packages using `python3 -m pip download`, or
-> manually from [pypi.org][pi] if your online and offline computers have
-> different architecture.
->
-> Transfer the downloaded files and cloned Git repositories to your offline
-> computer using a USB stick or other removable medium.  Install the
-> Debian/Ubuntu packages with `sudo dpkg -i` and the Python packages with
-> `python3 -m pip install --user`.
->
-> Clone the [secp256k1][ec] repository and copy it to `~/.cache/mmgen`
-> directory on the offline machine (or copy it from your online machine’s
-> `~/.cache/mmgen`).  Copy the MMGen repository to the offline machine and
-> install MMGen as described above.  If your online and offline machines have
-> different architecture, make sure to clean up any build/dist files in the
-> repositories before installing (in `secp256k1` this is accomplished by `make
-> clean`).
-
-Congratulations, your installation is now complete!  You can now proceed to
-[**Getting Started with MMGen**][gs].
-
-[01]: Install-Bitcoind
-[02]: Install-Bitcoind-from-Source-on-Debian-or-Ubuntu-Linux
-[ts]: Test-Suite
-[gs]: Getting-Started-with-MMGen
-[pi]: https://pypi.org
-[af]: Altcoin-and-Forkcoin-Support
-[ec]: https://github.com/bitcoin-core/secp256k1.git

+ 3 - 3
doc/wiki/install-mswin/Install-Bitcoind.md

@@ -83,7 +83,7 @@ $ bitcoind
 
 # Bitcoin Cash Node:
 $ mkdir $APPDATA/Bitcoin-Cash-Node
-$ bitcoind-bchn --listen=0 --rpcport=8442 --datadir=$APPDATA/Bitcoin-Cash-Node --usecashaddr=0
+$ bitcoind-bchn --listen=0 --rpcport=8432 --datadir=$APPDATA/Bitcoin-Cash-Node --usecashaddr=0
 
 # Litecoin
 $ litecoind
@@ -102,7 +102,7 @@ $ bitcoind --daemon
 
 # Bitcoin Cash Node:
 $ mkdir ~/.bitcoin-bchn
-$ bitcoind-bchn --daemon --listen=0 --rpcport=8442 --datadir=$HOME/.bitcoin-bchn --usecashaddr=0
+$ bitcoind-bchn --daemon --listen=0 --rpcport=8432 --datadir=$HOME/.bitcoin-bchn --usecashaddr=0
 
 # Litecoin:
 $ litecoind --daemon
@@ -115,7 +115,7 @@ $ litecoind --daemon
 $ bitcoin-cli help
 
 # Bitcoin Cash Node:
-$ bitcoin-cli-bchn --rpcport=8442 help
+$ bitcoin-cli-bchn --rpcport=8432 help
 
 # Litecoin:
 $ litecoin-cli help

+ 0 - 0
doc/wiki/install-mswin/Install-MMGen-on-Microsoft-Windows.md → doc/wiki/install-mswin/Install-MMGen-Wallet-on-Windows.md


+ 45 - 36
doc/wiki/using-mmgen/Altcoin-and-Forkcoin-Support.md → doc/wiki/using-mmgen-wallet/Altcoin-and-Forkcoin-Support.md

@@ -20,27 +20,28 @@
 
 Depending on your setup, the instructions on this page may apply to your
 offline machine, your online machine, or both.  If you’re confused as to
-which, please familiarize yourself with the basics of MMGen by reading the
-[**Getting Started**][gs] guide.
+which, please familiarize yourself with the basics of MMGen Wallet by
+reading the [**Getting Started**][gs] guide.
 
 ### <a id="a_eth">Ethereum (ETH), Ethereum Classic (ETC) and ERC20 Tokens</a>
 
-MMGen supports all operations for Ethereum, Ethereum Classic and ERC20 tokens.
-In addition, ERC20 token creation and deployment are supported via the
+MMGen Wallet supports all operations for Ethereum, Ethereum Classic and ERC20
+tokens.  In addition, ERC20 token creation and deployment are supported via the
 `create-token.py` script.
 
 #### <a id="a_ed">Install the Ethereum dependencies</a>
 
-From the MMGen repository root, type:
+From the MMGen Wallet repository root, type:
 
 ```text
-$ python3 -m pip install --no-deps --user -r eth-requirements.txt
+$ python3 -m pip install -r alt-requirements.txt # skip this for MSYS2
+$ python3 -m pip install --no-deps -r eth-requirements.txt
 ```
 
 #### <a id="a_geth">Install and run Geth or Parity</a>
 
-MMGen uses Go-Ethereum (Geth) to communicate with the Ethereum network.  For
-information on installing Geth on your system, visit the the Geth [Github
+MMGen Wallet uses Go-Ethereum (Geth) to communicate with the Ethereum network.
+For information on installing Geth on your system, visit the the Geth [Github
 repo][ge].  On Arch Linux systems, Go-Ethereum is a package and may be installed
 with `pacman`.
 
@@ -53,12 +54,12 @@ For Geth, the following command-line options are required:
 --http --http.api=eth,web3,txpool --http.port=8745
 ```
 
-Geth has dropped support for Ethereum Classic, but MMGen supports transacting
-ETC via the legacy [Parity][pd] daemon.  Invoke Parity with `--chain=classic
---jsonrpc-port=8645`.
+Geth has dropped support for Ethereum Classic, however transacting ETC is
+still supported by the legacy [Parity][pd] daemon.  Invoke Parity with
+`--chain=classic --jsonrpc-port=8645`.
 
-If you’re running Parity on a different machine from MMGen, add the following
-options to the command line:
+If you’re running Parity on a different machine from MMGen Wallet, add the
+following options to the command line:
 
 ```text
 --jsonrpc-hosts=all --jsonrpc-interface=<daemon IP address>
@@ -66,10 +67,9 @@ options to the command line:
 
 To run Parity offline, use `--mode=offline`, otherwise `--mode=active`.
 
-MMGen can also be used with Parity’s light client mode, which queries other
-nodes on the network for blockchain data.  Add the `--light` option to the
-Parity command line and read the applicable note in the [Transacting](#a_tx)
-section below.
+Parity’s light client mode, which queries other nodes on the network for
+blockchain data, is supported.  Add the `--light` option to the Parity command
+line and read the applicable note in the [Transacting](#a_tx) section below.
 
 You may require other options as well.  Invoke your daemon with the `--help`
 option for more complete information.
@@ -111,8 +111,8 @@ $ mmgen-addrimport --coin=eth --token-addr=86fa049857e0209aa7d9e616f7eb3b3b78ecf
 ```
 
 *Unlike the case with BTC and derivatives, ETH and ETC tracking wallets are
-created and managed by MMGen itself and located under the MMGen data directory.
-Token tracking wallets are located inside their underlying coin’s
+created and managed by MMGen Wallet itself and located under the MMGen data
+directory.  Token tracking wallets are located inside their underlying coin’s
 `tracking-wallet.json` file.  Address (account) balances are retrieved directly
 from the blockchain.  Tracking wallet views are separate for each token.*
 
@@ -150,8 +150,8 @@ To transact ETH instead of EOS, omit the `--token` and `--token-addr` arguments.
 
 ##### Install the Solidity compiler
 
-To deploy Ethereum contracts with MMGen, you need version **0.8.7** of the
-Solidity compiler (`solc`) installed on your system.  Although binary builds
+To deploy Ethereum contracts with MMGen Wallet, you need version **0.8.7** of
+the Solidity compiler (`solc`) installed on your system.  Although binary builds
 may be available for some distributions, the best way to ensure you have the
 correct version is to compile it from source.
 
@@ -177,7 +177,7 @@ must replace them with real ones.*
 Create a token 'MFT' with default parameters, owned by `ddeeff...` (`ABCDABCD:E:1`):
 
 ```text
-# Do this in the MMGen repository root:
+# Do this in the MMGen Wallet repository root:
 $ scripts/create-token.py --coin=ETH --symbol=MFT --name='My First Token' ddEEFFDdEEFfddEeffDDEefFdDeeFFDDEeFFddEe
 ```
 
@@ -212,29 +212,38 @@ for details.
 
 ### <a id="a_bch">Bitcoin Cash Node (BCH) and Litecoin (LTC)</a>
 
-Bitcoin Cash Node (BCH) and Litecoin are fully supported by MMGen, on the same
-level as Bitcoin.
+Bitcoin Cash Node (BCH) and Litecoin are fully supported by MMGen Wallet.
 
-To use MMGen with BCH or Litecoin, first make sure the Bitcoin Cash Node or
-Litecoin daemons are properly installed ([source][si])([binaries][bi]),
-[running][p8] and synced.
+To transact BCH or Litecoin, first make sure the Bitcoin Cash Node or Litecoin
+daemons are properly installed ([source][si])([binaries][bi]), [running][p8] and
+synced.
 
-MMGen requires that the bitcoin-bchn daemon be listening on non-standard
-[RPC port 8442][p8].  If your daemon version is >= 0.16.2, you must use the
+MMGen Wallet requires that the bitcoin-bchn daemon be listening on non-standard
+[RPC port 8432][p8].  If your daemon version is >= 0.16.2, you must use the
 `--usecashaddr=0` option.
 
-Then just add the `--coin=bch` or `--coin=ltc` option to all your MMGen
+Then just add the `--coin=bch` or `--coin=ltc` option to all your MMGen Wallet
 commands.  It’s that simple!
 
 ### <a id="a_xmr">Monero (XMR)</a>
 
-MMGen’s Monero support includes automated wallet creation/syncing and
+MMGen Wallet’s Monero support includes automated wallet creation/syncing and
 transacting via the [`mmgen-xmrwallet`][mx] command.  Make sure that
 [Monerod][M] is installed and running and that `monero-wallet-rpc` is located
 in your executable path.
 
+<a id="a_xmr_req">Install the Python XMR requirements:</a>
+
+(Note that this step is not required for MSYS2, as these requirements were
+already installed by pacman.)
+
+```text
+$ python3 -m pip install -r alt-requirements.txt
+$ python3 -m pip install -r xmr-requirements.txt
+```
+
 *The following instructions are applicable for a hot wallet setup.  To learn
-how to cold sign transactions using MMGen’s autosign feature, first
+how to cold sign transactions using MMGen Wallet’s autosign feature, first
 familiarize yourself with the basic concepts here and then consult the OFFLINE
 AUTOSIGNING tutorial on the [`mmgen-xmrwallet`][mx] help screen.*
 
@@ -280,7 +289,7 @@ To learn how to transact using your wallets, continue on to the
 
 ### <a id="a_zec">Key/address generation for Zcash (ZEC)</a>
 
-MMGen’s enhanced support for Zcash includes generation of **z-addresses.**
+MMGen Wallet supports generation of Zcash **z-addresses.**
 
 Generate ten Zcash z-address key/address pairs from your default wallet:
 
@@ -352,9 +361,9 @@ the MMGen Project.
 [P]: https://pypi.org/project/pip
 [M]: https://getmonero.org/downloads/#linux
 [X]: command-help-autosign
-[gs]: Getting-Started-with-MMGen
-[bo]: Getting-Started-with-MMGen#a_bo
-[si]: Install-Bitcoind-from-Source-on-Debian-or-Ubuntu-Linux
+[gs]: Getting-Started-with-MMGen-Wallet
+[bo]: Getting-Started-with-MMGen-Wallet#a_bo
+[si]: Install-Bitcoind-from-Source-on-Linux
 [bi]: Install-Bitcoind#a_d
 [p8]: Install-Bitcoind#a_r
 [ge]: https://github.com/ethereum/go-ethereum

+ 205 - 189
doc/wiki/using-mmgen/Getting-Started-with-MMGen.md → doc/wiki/using-mmgen-wallet/Getting-Started-with-MMGen-Wallet.md

@@ -6,7 +6,7 @@
 * [Configuration file](#a_cf)
 * [Bob and Alice regtest mode](#a_ts)
 
-#### [Generating an MMGen Wallet](#a_gw)
+#### [Generating a Wallet](#a_gw)
 
 #### [Transacting](#a_tr)
 * [Generate addresses](#a_ga)
@@ -19,8 +19,8 @@
 * [Using the mnemonic, seed and hexseed formats](#a_ms)
 * [Mnemonics, seeds and hexseeds: additional information](#a_ai)
 * [Die roll wallet generation](#a_dr)
-* [BIP39 mnemonic support](#a_39)
-* [Monero mnemonic support](#a_mm)
+* [BIP39 seed phrase support](#a_39)
+* [Monero seed phrase support](#a_mm)
 * [Incognito wallets](#a_ic)
 	* [Hidden incognito wallets](#a_hi)
 
@@ -30,7 +30,9 @@
 * [BIP 125 replace-by-fee (RBF) transactions](#a_rbf)
 	* [With an online (hot) wallet](#a_rbf_onl)
 	* [With an offline (cold storage) wallet](#a_rbf_onf)
-* [Keeping your installation up to date](#a_utd)
+* [Keeping your installation up to date](#a_ud)
+	* [Stable version](#a_uds)
+	* [Development version](#a_udd)
 
 ### <a id="a_i">Preliminaries</a>
 
@@ -46,26 +48,27 @@ commands and filenames) will speed up your work at the command line greatly.
 
 The examples in this tutorial are geared towards Bitcoin, but with some
 modification they may be used with altcoins and forkcoins for which MMGen
-supports transaction operations (BCH, LTC, ETH and ETC as of this writing).
-See [Altcoin-and-Forkcoin-Support][09] for more details.
+Wallet supports transaction operations (BCH, LTC, ETH, ETC and XMR as of this
+writing).  See [Altcoin-and-Forkcoin-Support][09] for more details.
 
 #### <a id="a_iv">Invocation</a>
 
-The MMGen wallet system is not a single program but a suite of lightweight
-scripts run from the command line.  MMGen’s commands all begin, not
-surprisingly, with `mmgen`.  To view all available commands, type `mmgen`
-followed by the TAB key.  Every mmgen command has a help screen displaying
-detailed usage and options information.  To view it, type the command name
-followed by `--help`.  Note that most command options have long and short
-versions.  For example, the `--help` option may be abbreviated to `-h`.
-Exceptions are the options listed by `--longhelp`, which have no short versions.
-
-MMGen commands are generally interactive, providing you with information and
-prompting you for input.  The `--verbose` or `-v` option requests commands to be
-more wordy, while the `--quiet` or `-q` option suppresses all but the most
-essential information.  These options are available for all MMGen commands.  The
-`--yes` option (available only for certain commands) suppresses even more
-information and can be used to make some commands non-interactive and scriptable.
+MMGen Wallet is not a single program but a suite of lightweight scripts run from
+the command line.  Commands all begin, not surprisingly, with `mmgen`, and thus
+you may view all available commands by typing `mmgen` followed by the TAB key.
+Every command has a help screen displaying detailed usage and options
+information.  To view it, type the command name followed by `--help`.  Note that
+most command options have long and short versions.  For example, the `--help`
+option may be abbreviated to `-h`.  Exceptions are the options listed by
+`--longhelp`, which have no short versions.
+
+MMGen Wallet’s commands are generally interactive, providing you with information
+and prompting you for input.  The `--verbose` or `-v` option requests commands
+to be more wordy, while the `--quiet` or `-q` option suppresses all but the most
+essential information.  These options are available for all MMGen Wallet
+commands.  The `--yes` option (available only for certain commands) suppresses
+even more information and can be used to make some commands non-interactive and
+scriptable.
 
 Certain options require parameters, such as the `--seed-len` option, for
 instance, which takes a parameter of `128`, `192` or `256`.  Commands may also
@@ -73,7 +76,7 @@ take optional or required arguments.  For example, `mmgen-addrgen` requires an
 address or range of addresses as an argument.  Arguments must always follow
 options on the command line.
 
-Sample MMGen command invocations:
+Sample command invocations:
 
 ```text
 $ mmgen-txcreate --help
@@ -84,48 +87,48 @@ $ mmgen-walletgen --quiet --seed-len 128
 
 #### <a id="a_cf">Configuration file</a>
 
-Just like Bitcoin Core, MMGen has its own data directory and configuration file.
-The data directory is `.mmgen` in the user’s home directory and the config
-file is `mmgen.cfg`.  The config file contains global settings which you may
-wish to edit at some point to customize your installation.  These settings
-include the maximum transaction fee; the user name, password and hostname
-used for communicating with your Bitcoin or altcoin daemon; and a number of
-others.
+Just like Bitcoin Core, MMGen Wallet has its own data directory and
+configuration file.  The data directory is `.mmgen` in the user’s home directory
+and the config file is `mmgen.cfg`.  The config file contains global settings
+which you may wish to edit at some point to customize your installation.  These
+settings include the maximum transaction fee; the user name, password and
+hostname used for communicating with your Bitcoin or altcoin daemon; and a
+number of others.
 
 #### <a id="a_ts">Bob and Alice regtest mode</a>
 
-If you just want to quickly try out MMGen, it’s possible to perform all wallet
-generation, wallet format conversion, address and key generation, and address
-import operations on an offline computer with no blockchain and no bitcoin
-balance.
+If you just want to quickly test using MMGen Wallet, it’s possible to perform
+all wallet generation, wallet format conversion, address and key generation, and
+address import operations on an offline computer with no blockchain and no
+bitcoin balance.
 
 If you want to practice creating, signing and sending transactions with real
 bitcoins, however, you’ll need a fully synced blockchain and some coins to play
 with.  This involves an expenditure of both time and money.
 
-Fortunately, there’s an alternative: MMGen’s **regtest mode** creates a virtual
-network of two users, Bob and Alice, who transact with each other on a private
-blockchain.  All of MMGen’s functionality is available in regtest mode, making
-it an ideal way to learn to use the MMGen wallet without risking real coins.
-You may wish to pause here and perform the steps in the tutorial [MMGen Quick
-Start with Regtest Mode][04] before continuing on.
+Fortunately, there’s an alternative: MMGen Wallet’s **regtest mode** creates a
+virtual network of two users, Bob and Alice, who transact with each other on a
+private blockchain.  All of MMGen Wallet’s functionality is available in regtest
+mode, making it an ideal way to learn to use the wallet without risking real
+coins.  You may wish to pause here and perform the steps in the tutorial [MMGen
+Wallet Quick Start with Regtest Mode][04] before continuing on.
 
-### <a id="a_gw">Generating an MMGen Wallet</a>
+### <a id="a_gw">Generating a Wallet</a>
 
-*NOTE: MMGen supports a “default wallet” feature.  After generating your wallet,
-you’ll be prompted to make it your default.  If you answer ‘y’, the wallet will
-be stored in your MMGen data directory and used for all future commands that
-require a wallet or other seed source.*
+*NOTE: MMGen Wallet supports a “default wallet” feature.  After generating your
+wallet, you’ll be prompted to make it your default.  If you answer ‘y’, the
+wallet will be stored in your MMGen data directory and used for all future
+commands that require a wallet or other seed source.*
 
-*You may not want this feature if you plan to store your MMGen wallet in a
-location other than your MMGen data directory.  Otherwise, it’s recommended,
-as it frees you from having to type your wallet filename on the command line.*
+*You may not want this feature if you plan to store your wallet in a location
+other than your MMGen data directory.  Otherwise, it’s recommended, as it frees
+you from having to type your wallet filename on the command line.*
 
 *The following examples assume that you’ve chosen to use a default wallet.
 If you haven’t, then you must include the path to a wallet file or other seed
 source in all commands where a seed source is required.*
 
-On your **offline** computer, generate an MMGen wallet:
+On your **offline** computer, generate a wallet:
 
 ```text
 $ mmgen-walletgen
@@ -144,12 +147,12 @@ preset are changed and doesn’t need to be memorized.
 `256` is the seed length; `3` is the scrypt hash preset.  These values are
 configurable: type `mmgen-walletgen --help` for details.
 
-Before moving any funds into your MMGen wallet, you should back it up in several
+Before transferring funds into your wallet, you should back it up in several
 places and preferably on several media such as paper, flash memory or optical
 disk.  You’re advised to use a passphrase with your wallet.  Otherwise, anyone
 who gains physical access to one of your backups can easily steal your coins.
-Don’t forget your passphrase.  If you do, the coins in your MMGen wallet are
-gone forever.
+Don’t forget your passphrase.  If you do, the coins in your wallet are gone
+forever.
 
 Since the wallet is a small, humanly readable ASCII file, it can easily be
 printed out on paper.
@@ -194,19 +197,19 @@ $ cat '89ABCDEF-S[1-10].addrs'
 Note that the address range `1-10` specified on the command line is included in
 the resulting filename.
 
-MMGen currently supports four address types for Bitcoin and Bitcoin code fork
-coins: `legacy` (uncompressed P2PKH), `compressed` (compressed P2PKH),
-`segwit` (P2SH-P2WPKH) and `bech32` (native Segwit), denoted by the code
-letters `L`, `C`, `S` and `B` respectively.  Address types can be referred to
-either in full or by code letter.  To generate Bech32 addresses, for example,
-you can specify either `--type=bech32` or `--type=B` on the command line.
+MMGen Wallet currently supports four address types for Bitcoin and Bitcoin code
+fork coins: `legacy` (uncompressed P2PKH), `compressed` (compressed P2PKH),
+`segwit` (P2SH-P2WPKH) and `bech32` (native Segwit), denoted by the code letters
+`L`, `C`, `S` and `B` respectively.  Address types can be referred to either in
+full or by code letter.  To generate Bech32 addresses, for example, you can
+specify either `--type=bech32` or `--type=B` on the command line.
 
 For backwards compatibility, legacy addresses with uncompressed public keys
 are generated by default, but this is almost certainly not what you want
-unless you’re restoring an old MMGen installation created before compressed
-address support was added.  Most new users will wish to generate either
-Segwit-P2SH (`S`) or Bech32 (`B`) addresses instead.  For BCH, which lacks
-Segwit support, compressed (`C`) addresses are the best choice.
+unless you’re restoring an old MMGen Wallet installation created before
+compressed address support was added.  Most new users will wish to generate
+either Segwit-P2SH (`S`) or Bech32 (`B`) addresses instead.  For BCH, which
+lacks Segwit support, compressed (`C`) addresses are the best choice.
 
 Generation examples for various address types:
 
@@ -246,8 +249,8 @@ $ cat '89ABCDEF-B[1-10].addrs'
 Note that for non-legacy address types the code letter is included in the
 filename.
 
-To fund your MMGen wallet, first import the addresses into your tracking wallet
-and then send some coins to any of them.  If you run out of addresses, generate
+To fund your wallet, first import the addresses into your tracking wallet and
+then send some coins to any of them.  If you run out of addresses, generate
 more.  To generate a hundred addresses you’d specify an address range of
 `1-100`.
 
@@ -294,20 +297,16 @@ Save the file, copy it onto a USB stick and transfer it to your online computer.
 
 #### <a id="a_ia">Import addresses (online computer)</a>
 
-On your online computer, go to your coin daemon’s data directory (`~/.bitcoin`
-by default for Bitcoin Core) and move any existing `wallet.dat` file out of
-harm’s way.  With more recent coin daemons, `wallet.dat` can be found in the
-`wallets` subdirectory of the daemon data directory.
-
 Start the coin daemon with the required options (see the [Install-Bitcoind][08]
 wiki page for more details on invoking the daemon for your coin and platform).
 
-Upon startup, older daemons will automatically generate a new default
-`wallet.dat`, which MMGen will use as its tracking wallet.  With newer daemons
-(e.g. Core 0.21.0 and above), the tracking wallet will be a directory named
-`mmgen-tracking-wallet` located by default under the `wallets` subdirectory.
+Upon startup, older daemons used to automatically generate a new default
+`wallet.dat`, which MMGen Wallet used as its tracking wallet.  With newer
+daemons (e.g. Core 0.21.0 and above), the tracking wallet will be a directory
+named `mmgen-tracking-wallet`, located by default under the `wallets`
+subdirectory in your daemon’s datadir.
 
-Import your ten addresses into the new tracking wallet with the command:
+Import the ten addresses into your new tracking wallet with the command:
 
 ```text
 $ mmgen-addrimport --batch my.addrs
@@ -331,10 +330,10 @@ TOTAL: 0 BTC
 ```
 
 *While not covered in this introduction, note that it’s also possible to [import
-external coin addresses into your tracking wallet][01].  This allows you to
-track and spend funds from another wallet with MMGen without having to go
-through the network.  To do this, you must save the keys corresponding to the
-given addresses in a separate file for use during transaction signing.*
+external coin addresses into your tracking wallet][01].  This allows MMGen
+Wallet to track and spend funds from another wallet without having to transfer
+the coins through the network.  To do this, you must save the keys corresponding
+to the given addresses in a separate file for use during transaction signing.*
 
 Note that each address has a unique ID (the ‘MMGen ID’) consisting of a Seed ID,
 address type code letter, and index.  Addresses of different types may be
@@ -360,8 +359,8 @@ TOTAL: 1 BTC
 
 #### <a id="a_ct">Create a transaction (online computer)</a>
 
-Now that you have some BTC under MMGen’s control, you’re ready to create a
-transaction.  Note that transactions are harmless until they’re signed and
+Now that you have some BTC under MMGen Wallets’s control, you’re ready to create
+a transaction.  Note that transactions are harmless until they’re signed and
 broadcast to the network, so feel free to experiment and create transactions
 with different combinations of inputs and outputs.  Of course, if you’re using
 testnet or regtest mode, then you risk nothing even when broadcasting
@@ -437,8 +436,9 @@ Transaction written to file 'FEDCBA[0.1].rawtx'
 The transaction filename consists of a unique MMGen Transaction ID plus the
 non-change spend amount.
 
-As you can see, MMGen gives you complete control over your transaction inputs
-and change addresses.  This feature will be appreciated by privacy-conscious users.
+As you can see, MMGen Wallet gives you complete control over your transaction
+inputs and change addresses.  This feature will be appreciated by
+privacy-conscious users.
 
 #### <a id="a_sg">Sign a transaction (offline computer)</a>
 
@@ -466,10 +466,10 @@ $ mmgen-txsend FEDCBA[0.1].sigtx
 Transaction sent: abcd1234....
 ```
 
-Like all MMGen commands, `mmgen-txsend` is interactive, so you’ll be prompted
-before the transaction is actually broadcast.  If the send was successful, a
-64-character hexadecimal Bitcoin Transaction ID will be displayed (`abcd1234...`
-in our case).
+Like all MMGen Wallet commands, `mmgen-txsend` is interactive, so you’ll be
+prompted before the transaction is actually broadcast.  If the send was
+successful, a 64-character hexadecimal Bitcoin Transaction ID will be displayed
+(`abcd1234...` in our case).
 
 Once the transaction is broadcast to the network and confirmed, your address
 listing should look something like this:
@@ -501,14 +501,15 @@ Network: BTC MAINNET
 Since you’ve sent 0.1 BTC to a third party, your balance has decreased by 0.1
 BTC plus the transaction fee of 0.0001 BTC.
 
-Congratulations!  You’ve now mastered the basics of MMGen!  To learn about some
-of MMGen’s more advanced features, continue reading.
+Congratulations!  You’ve now mastered the basics of MMGen Wallet!  To learn
+about some more advanced features, continue reading.
 
 ### <a id="a_af">Additional Features</a>
 
 #### <a id="a_ms">Using the mnemonic, seed and hexseed formats</a>
 
-Using your default wallet from the exercises above, generate a mnemonic:
+Using your default wallet from the exercises above, generate a mnemonic seed
+phrase:
 
 ```text
 $ mmgen-walletconv -o words
@@ -521,21 +522,21 @@ float absent path strong curtain savior worst suspend bright touch away
 dirty measure thorn
 ```
 
-Since our seed is 256 bits long, the mnemonic contains 24 words.  128-bit and
+Since our seed is 256 bits long, the seed phrase contains 24 words.  128-bit and
 192-bit seeds generate shorter mnemonics of 12 and 18 words, respectively.
 Wallets with these seed lengths can be generated using the `--seed-len` option
 to `mmgen-walletgen`.
 
 Though some consider 128 bits of entropy to provide adequate security for the
 foreseeable future, it’s advisable to stick to the default 256-bit seed length.
-You’ll find that even a 24-word mnemonic is not difficult to memorize.
+You’ll find that even a 24-word seed phrase is not difficult to memorize.
 
 NOTE: MMGen mnemonics are generated from the Electrum wordlist, but using
 ordinary base conversion instead of Electrum’s more complicated algorithm.
 
-The mnemonic is a complete representation of your seed and may be used anywhere
-where you’d use an MMGen wallet.  You can generate addresses with it just as you
-do with a wallet:
+The seed phrase is a complete representation of your seed and may be used
+anywhere where you’d use a wallet.  For example, you can generate addresses with
+it:
 
 ```text
 $ mmgen-addrgen --type=segwit 89ABCDEF.mmwords 1-10
@@ -551,7 +552,7 @@ $ mmgen-txsign FEDCBA[0.1].rawtx 89ABCDEF.mmwords
 Signed transaction written to file 'FEDCBA[0.1].sigtx'
 ```
 
-The mnemonic can also be used to regenerate a lost wallet:
+The seed phrase can also be used to regenerate a lost wallet:
 
 ```text
 $ mmgen-walletconv 89ABCDEF.mmwords
@@ -562,7 +563,7 @@ MMGen wallet written to file '89ABCDEF-01234567[256,3].mmdat'
 Note that the regenerated wallet has a different Key ID but of course the same
 Seed ID.
 
-An alternative to mnemonics, seed files provide yet another way of representing
+An alternative to seed phrases, seed files provide yet another way of representing
 your seed.  They bear the extension `.mmseed` and are generated exactly the same
 way as mnemonic files:
 
@@ -610,9 +611,9 @@ $ mmgen-tool str2id6 'XnyC NfPH piuW dQ2d nM47 VU'
 0fe02f
 ```
 
-Beginning with version 0.9.0, MMGen also supports seed files in hexadecimal
-(hexseed) format.  Hexseed files are identical to seed files but encoded in
-hexadecimal rather than base 58.  They bear the extension `.mmhex`:
+Beginning with version 0.9.0, MMGen Wallet also supports seed files in
+hexadecimal (hexseed) format.  Hexseed files are identical to seed files but
+encoded in hexadecimal rather than base 58.  They bear the extension `.mmhex`:
 
 ```text
 $ cat FE3C6545.mmhex
@@ -628,16 +629,16 @@ fe3c6545
 ```
 
 Mnemonics and hexseeds can be used to generate keys even without the MMGen
-software, using basic command-line utilities, as explained in [this
+Wallet software, using basic command-line utilities, as explained in [this
 tutorial][03].
 
 #### <a id="a_ai">Mnemonics, seeds and hexseeds: additional information</a>
 
-All MMGen commands that take mnemonic, seed or hexseed data may receive the data
-interactively from the user instead of from a file.  This feature allows you to
-store your seed entirely in your head if you wish and never record it on a
-physical medium.  To input your seed data at the prompt, just specify an input
-format instead of a file name:
+All MMGen Wallet commands that take mnemonic, seed or hexseed data may receive
+the data interactively from the user instead of from a file.  This feature
+allows you to store your seed entirely in your head if you wish and never record
+it on a physical medium.  To input your seed data at the prompt, just specify an
+input format instead of a file name:
 
 ```text
 $ mmgen-addrgen -i words 1-10
@@ -648,28 +649,28 @@ Enter your 12-word mnemonic, hitting RETURN or SPACE after each word:
 Enter word #1:
 ```
 
-Here MMGen prompts you interactively for each word of the seed phrase, checking
-it for validity and reprompting if necessary.  The words are not displayed on
-the screen.
+Here the script will prompt you interactively for each word of the seed phrase,
+checking it for validity and reprompting if necessary.  The words are not
+displayed on the screen.
 
 As a safeguard against over-the-shoulder, Tempest and other side-channel
-attacks, MMGen never outputs secret data to the screen, unless you ask it to
-with the `--stdout` or `-S` option.  When using this option, you’ll still be
-prompted before the secret data is actually displayed.  This safety prompt is
-overridden by the `--quiet` option, however, so you must always think twice
-before using `--stdout`.
-
-The output of any MMGen command may be written to a directory of your choice
-using the `--outdir` or `-d` option.  For example, on a Linux system you can use
-`--outdir=/dev/shm` to write keys and seeds to volatile memory instead of disk,
-ensuring that no trace of your secret data remains once your computer’s been
-powered down.
+attacks, MMGen Wallet never outputs secret data to the screen, unless you
+explicitly ask it to with the `--stdout` or `-S` option.  And even with this
+option in effect, you’ll still be prompted before the secret data is actually
+displayed.  This guard prompt is overridden by the `--quiet` option, however,
+always think twice before using `--stdout` together with `--quiet`.
+
+Files produced by MMGen Wallet’s commands may be written to a directory of your
+choice using the `--outdir` or `-d` option.  For example, on a Linux system you
+can use `--outdir=/dev/shm` to write keys and seeds to volatile memory instead
+of disk, ensuring that no trace of your secret data remains once your computer’s
+been powered down.
 
 #### <a id="a_dr">Die roll wallet generation</a>
 
 Interactive dieroll wallet generation works just like the interactive mnemonic
-input described in the preceding section.  To generate a new dieroll wallet,
-type:
+seed phrase input described in the preceding section.  To generate a new dieroll
+wallet, type:
 
 ```text
 $ mmgen-walletconv -i dieroll
@@ -684,11 +685,11 @@ $ mmgen-walletconv -i dieroll -o bip39
 50, 75 and 100 rolls of the die are required to create 128, 192 and 256-bit
 seeds, respectively.
 
-#### <a id="a_39">BIP39 support</a>
+#### <a id="a_39">BIP39 seed phrase support</a>
 
-BIP39 mnemonic support and usage is identical to that for native MMGen mnemonics
-described above.  Just use the `bip39` format specifier and extension instead of
-`words`.
+BIP39 mnemonic seed phrase support and usage is identical to that for native
+MMGen mnemonics described above.  Just use the `bip39` format specifier and
+extension instead of `words`.
 
 Convert an MMGen native mnemonic wallet to BIP39:
 
@@ -696,21 +697,21 @@ Convert an MMGen native mnemonic wallet to BIP39:
 $ mmgen-walletconv -o bip39 mywallet.words
 ```
 
-Restore an MMGen wallet from a BIP39 seed phrase in a file:
+Restore a wallet from a BIP39 seed phrase in a file:
 
 ```text
 $ mmgen-walletconv seed.bip39
 ```
 
-#### <a id="a_mm">Monero mnemonic support</a>
+#### <a id="a_mm">Monero seed phrase support</a>
 
-MMGen has limited support for Monero new-style mnemonics.  While they can’t be
-used as wallets, they’re supported as a password format by the `mmgen-passgen`
-command and can be converted to and from hex data by the `mmgen-tool` mnemonic
-commands.  The format specifier and extension is `xmrseed`.  Only 25-word
-mnemonics (256-bit keys) are supported.  Key data is reduced in accordance with
-the Monero protocol before conversion, so the resulting mnemonics are guaranteed
-to be canonical.
+MMGen Wallet has limited support for Monero new-style mnemonic seed phrases.
+While they can’t be used as wallets, they’re supported as a password format by
+the `mmgen-passgen` command and can be converted to and from hex data by the
+`mmgen-tool` mnemonic commands.  The format specifier and extension is
+`xmrseed`.  Only 25-word seed phrases (256-bit keys) are supported.  Key data
+is reduced in accordance with the Monero protocol before conversion, so the
+resulting seed phrases are guaranteed to be canonical.
 
 Generate a random Monero seed phrase:
 
@@ -736,8 +737,8 @@ interest at all, for that matter.
 An incognito wallet with a reasonably secure password could even be hidden on
 unencrypted cloud storage.  Hiding your wallet at some offset in a 1GB file
 increases the difficulty of any attack by a factor of one billion, assuming
-again that any potential attacker even knows or suspects you have an MMGen
-wallet hidden there.
+again that any potential attacker even knows or suspects you have a wallet
+hidden there.
 
 If you plan to store your incognito wallet in an insecure location such as cloud
 storage, you’re advised to use a strong scrypt (hash) preset and a strong
@@ -800,7 +801,7 @@ This data is ideally suited for a paper wallet that could potentially fall into
 the wrong hands.
 
 Your incognito wallet (whether hex or binary) can be used just like any other
-MMGen wallet, mnemonic or seed file to generate addresses and sign transactions:
+wallet, mnemonic or seed file to generate addresses and sign transactions:
 
 ```text
 $ mmgen-addrgen --type=segwit 89ABCDEF-87654321-CA86420E[256,5].mmincox 101-110
@@ -870,22 +871,23 @@ Signed transaction written to file 'ABCDEF[0.1].sigtx'
 
 #### <a id="a_hw">Hot wallets</a>
 
-Chances are you’ll want to use MMGen not only for cold storage but for
-day-to-day transactions too.  For this you’ll need to place a portion of your
-funds in a “hot wallet” on your online computer.  With a hot wallet you can use
-the command `mmgen-txdo` to quickly create, sign and send transactions in one
-operation.
+*Instead of using a hot wallet, you should consider setting up [transaction
+autosigning][07] on your offline machine.  Autosigning makes it possible to
+transact directly from cold storage in a secure and convenient way.  Autosigning
+is available for Linux-based systems and is tailored for use with Raspberry Pi
+and other single-board computers, for which LED support is provided.  Old
+laptops with their network interfaces disabled also make acceptable signing
+devices.*
 
-*Note: prior to Version 0.11.0, MMGen implemented hot wallets using [key-address
-files][05], but these have now been obsoleted by [subwallets][06].  Information
-on key-address files is archived [here][05] for the benefit of legacy
-installations only.*
+To use MMGen Wallet for not only cold storage but also day-to-day transacting,
+it’s possible to place a portion of your funds in a “hot wallet” on your online
+computer.  You may then use the `mmgen-txdo` command to quickly create, sign and
+send transactions in one operation.
 
-*Additional note: instead of using a hot wallet, you might consider setting up
-[transaction autosigning][07] on your offline machine.  Autosigning makes it
-possible to transact directly from cold storage in a secure and convenient way.
-Autosigning is available for Linux-based systems only and works best with
-Raspberry Pi and similar devices, for which LED support is provided.*
+*Note: prior to Version 0.11.0, MMGen Wallet implemented hot wallets using
+[key-address files][05], but these have now been obsoleted by [subwallets][06].
+Information on key-address files is archived [here][05] for the benefit of
+legacy installations only.*
 
 Setting up a hot wallet is easy.  Using the [Subwallets][06] wiki page as your
 guide, generate a subwallet on your offline machine for use as a hot wallet.
@@ -948,32 +950,33 @@ control.
 
 #### <a id="a_fee">Transaction Fees</a>
 
-MMGen gives you several options for dealing with transaction fees.
+MMGen Wallet gives you several options for dealing with transaction fees.
 
-Firstly, and most simply, you may do nothing, in which case MMGen will calculate
-the fee automatically using bitcoind’s `estimatefee` RPC call.  You can adjust
-the estimated fee by any factor using the `--tx-fee-adj` option, a handy feature
-when you need transactions to confirm a bit more quickly.  MMGen has no default
-fee, so if network fee estimation fails for any reason, you’ll be prompted to
-enter the fee manually.
+Firstly, and most simply, you may do nothing, in which case the fee will be
+calculated automatically using bitcoind’s `estimatesmartfee` RPC call.  You can
+adjust the estimated fee by any factor using the `--tx-fee-adj` option, a handy
+feature when you need transactions to confirm a bit more quickly.  If network
+fee estimation fails for any reason, you’ll be prompted to enter the fee
+manually.
 
 Secondly, you may specify the fee as an absolute BTC amount (a decimal number).
 This can be done either on the command line or at the interactive prompt when
 creating transactions with `mmgen-txcreate`, `mmgen-txdo` or `mmgen-txbump`.
 
 Thirdly, instead of using an absolute BTC amount, you may specify the fee in
-satoshis per byte and let MMGen calculate the fee based on the transaction size.
-This also works both on the command line and at the interactive prompt.  The
-satoshis-per-byte specification is an integer followed by the letter `s`.  A fee
-of 90 satoshis per byte is thus represented as `90s`.
+satoshis per byte and let MMGen Wallet calculate the fee based on the
+transaction size.  This also works both on the command line and at the
+interactive prompt.  The satoshis-per-byte specification is an integer followed
+by the letter `s`.  A fee of 90 satoshis per byte is thus represented as `90s`.
 
-MMGen has a hard maximum fee (currently 0.003 BTC) which is alterable only in the
-config file.  Thus MMGen will never create or broadcast any transaction with a
-mistakenly or dangerously high fee unless you expressly permit it to.
+MMGen Wallet enforces a hard maximum fee (currently 0.003 BTC) which is
+alterable only in the config file.  Thus the software will never create or
+broadcast any transaction with a mistakenly or dangerously high fee unless you
+expressly permit it to.
 
 #### <a id="a_rbf">BIP 125 replace-by-fee (RBF) transactions</a>
 
-As of version 0.9.1, MMGen supports creating replaceable and replacement
+As of version 0.9.1, MMGen Wallet supports creating replaceable and replacement
 transactions in accordance with the BIP 125 replace-by-fee (RBF) specification.
 
 To make your transactions replaceable, just specify the `--rbf` option when
@@ -1081,19 +1084,39 @@ $ mmgen-txsend 124FFF[0.1,150].sigtx  # ...if this doesn’t confirm, then
 $ mmgen-txsend 73DABB[0.1,200].sigtx
 ```
 
-#### <a id="a_utd">Keeping your installation up to date</a>
+#### <a id="a_ud">Keeping your installation up to date</a>
 
 To make sure you have all the latest features and bugfixes, it’s a good idea to
-keep your MMGen installation upgraded to the latest version.  MMGen does no
-checking for updates itself, so the following steps should be performed by you
-on a periodic basis.
+keep your MMGen Wallet installation upgraded to the latest version.  The
+software does no checking for updates, so it’s up to you to do so yourself on a
+periodic basis.
+
+##### <a id="a_uds">Stable version:</a>
 
-If you’ve deleted or lost your local copy of the MMGen repository, clone it
-again from Github or Gitlab:
+To update the stable version, simply perform:
 
 ```text
-$ git clone https://github.com/mmgen/mmgen.git # Github
-$ git clone https://gitlab.com/mmgen/mmgen.git # Gitlab
+$ python3 -m pip install --update mmgen-wallet
+```
+
+For an offline installation, download the package on your online machine with
+`pip download`, transfer the downloaded package to your offline machine and
+install it with `pip install --no-isolation`.
+
+Note that additional dependencies may appear from version to version, causing
+an offline installation to fail.  Consult the latest release notes in
+`doc/release-notes` or your platform’s installation page in the wiki
+([Linux][li], [Windows][wi]) for more information.
+
+##### <a id="a_udd">Development version:</a>
+
+If you’ve deleted or lost your local copy of the MMGen Wallet repository, clone
+it again from Github, Gitlab or mmgen.org:
+
+```text
+$ git clone https://github.com/mmgen/mmgen.git
+$ git clone https://gitlab.com/mmgen/mmgen.git
+$ git clone https://mmgen.org/project/mmgen/mmgen.git
 ```
 
 Enter the repository and check out the master branch.  Pull the latest changes
@@ -1105,31 +1128,22 @@ $ git checkout master
 $ git pull
 ```
 
-Check out the current stable version for your operating system:
-
-```text
-$ git checkout stable_linux # for Linux-based systems
-$ git checkout stable_msys2 # for Microsoft Windows / MSYS2 systems
-```
-
-Note that if you want to try out the latest “bleeding edge” (and possibly
-unstable) features, you can just remain on the master branch and omit the
-preceding step.  Information on recently added features can be found by typing
-`git log` or visiting the online [commits page][cp].
+Newly added features may not yet be covered in the documentation, but you may
+often find information on them by invoking `git log` or visiting the online
+[commits page][cp].
 
-Check the latest release notes in `doc/release-notes` and make note of any new
-features or requirements.  Now build and install:
+Now build and install:
 
 ```text
-$ rm -rf dist build
+$ rm -rf dist build *.egg-info
 $ python3 -m build --no-isolation
-$ python3 -m pip install --user --upgrade dist/*.whl
+$ python3 -m pip install user --upgrade dist/*.whl
 ```
 
 [01]: Tracking-and-spending-ordinary-Bitcoin-addresses
 [02]: https://tpfaucet.appspot.com
 [03]: Recovering-Your-Keys-Without-the-MMGen-Software
-[04]: MMGen-Quick-Start-with-Regtest-Mode
+[04]: MMGen-Wallet-Quick-Start-with-Regtest-Mode
 [05]: Key-address-files
 [06]: Subwallets
 [07]: command-help-autosign
@@ -1138,3 +1152,5 @@ $ python3 -m pip install --user --upgrade dist/*.whl
 [ax]: Altcoin-and-Forkcoin-Support#a_xmr
 [cp]: ../commits/master
 [mx]: command-help-xmrwallet
+[li]: Install-MMGen-Wallet-on-Linux
+[wi]: Install-MMGen-Wallet-on-Microsoft-Windows

+ 8 - 8
doc/wiki/using-mmgen/MMGen-Quick-Start-with-Regtest-Mode.md → doc/wiki/using-mmgen-wallet/MMGen-Wallet-Quick-Start-with-Regtest-Mode.md

@@ -3,21 +3,21 @@ daemon’s regression test feature to create a virtual network of two users who
 transact on a private blockchain.
 
 All of MMGen’s functionality is available in regtest mode, making it an ideal
-way to learn to use the MMGen wallet without risking real coins.
+way to learn to use MMGen Wallet without risking real coins.
 
 To send a transaction or perform any other operation as Bob or Alice, just add
-the `--bob` or `--alice` option to the applicable MMGen command.
+the `--bob` or `--alice` option to the applicable MMGen Wallet command.
 
 This tutorial provides a quick, hands-on introduction.
 
-1. Initialize MMGen regtest mode and start the regtest daemon:
+1. Initialize regtest mode and start the regtest daemon:
 
 ```text
 $ mmgen-regtest setup
 $ mmgen-regtest start
 ```
 
-2. Generate Bob’s MMGen wallet:
+2. Generate Bob’s wallet:
 
 ```text
 $ mmgen-walletgen --bob
@@ -25,7 +25,7 @@ $ mmgen-walletgen --bob
 Make this wallet your default and move it to the data directory? (Y/n): y
 ```
 
-3. Generate three type `C` (compressed) addresses with Bob’s MMGen wallet:
+3. Generate three type `C` (compressed) addresses with Bob’s wallet:
 
 ```text
 $ mmgen-addrgen --bob --type=compressed 1-3
@@ -84,7 +84,7 @@ TOTAL: 500 BTC
 $ mmgen-tool --bob getbalance
 ```
 
-9. Generate Alice’s MMGen wallet:
+9. Generate Alice’s wallet:
 
 ```text
 $ mmgen-walletgen --alice
@@ -92,7 +92,7 @@ $ mmgen-walletgen --alice
 Make this wallet your default and move it to the data directory? (Y/n): y
 ```
 
-10. Generate three type `S` (segwit) addresses with Alice’s MMGen wallet:
+10. Generate three type `S` (segwit) addresses with Alice’s wallet:
 
 ```text
 $ mmgen-addrgen --alice --type=segwit 1-3
@@ -224,4 +224,4 @@ TOTAL: 510 BTC
 $ mmgen-regtest stop
 ```
 
-[G]: Getting-Started-with-MMGen#a_ct
+[G]: Getting-Started-with-MMGen-Wallet#a_ct

+ 12 - 12
doc/wiki/using-mmgen/Recovering-Your-Keys-Without-the-MMGen-Software.md → doc/wiki/using-mmgen-wallet/Recovering-Your-Keys-Without-the-MMGen-Software.md

@@ -12,10 +12,10 @@
 
 #### <a id="a_i">Introduction</a>
 
-If you’re considering using MMGen and are a Bitcoiner with a normal, healthy
-degree of paranoia, then the following question will probably come to mind:
-“What if I have funds in an MMGen wallet and I lose the software?  How do I
-recover my coins?”
+If you’re considering using MMGen Wallet and are a Bitcoiner with a normal,
+healthy degree of paranoia, then the following question will probably come to
+mind: “What if I have funds in MMGen Wallet and I lose the software?  How do
+I recover my coins?”
 
 Let’s take this scenario to its logical extreme and assume you’ve lost all
 backup copies of the software, MMGen’s project page has disappeared from both
@@ -32,8 +32,8 @@ generated with the `mmgen-passgen` command.
 To keep things simple, we’ll assume you have a copy of your seed in hexadecimal
 (mmhex) format.  If your backup’s in mnemonic format, skip to the section
 [Converting an MMGen mnemonic to hexadecimal format](#a_mh) below and return
-here when you’ve finished.  If your backup is an MMGen wallet, it will need to
-be decrypted.  That case will be covered in a future tutorial.
+here when you’ve finished.  If your backup is in default wallet format, it will
+need to be decrypted.  That case will be covered in a future tutorial.
 
 Okay, so let’s say you have a 128-bit seed with Seed ID `FE3C6545` and funds in
 the first three legacy uncompressed (`L`) addresses of this seed.  Here are the
@@ -156,9 +156,9 @@ $ mv scrambled-round10.bin myseed.bin
 
 #### <a id="a_gk">Generating the keys</a>
 
-The MMGen key-generating algorithm uses a chain of SHA-512 hashes with double
-SHA-256 branches to generate the keys from which each address is derived.  To
-obtain the chain’s first link, we make a single SHA-512 hash of the seed and
+MMGen Wallet’s key-generating algorithm uses a chain of SHA-512 hashes with
+double SHA-256 branches to generate the keys from which each address is derived.
+To obtain the chain’s first link, we make a single SHA-512 hash of the seed and
 save it in binary form:
 
 ```bash
@@ -414,9 +414,9 @@ Or in exponential notation:
 1 x 10³
 ```
 
-An MMGen seed mnemonic is a number too, only the “digits” it’s comprised of come
-from an alphabetically sorted series of 1626 words, the [Electrum wordlist][03],
-which begins like this:
+An MMGen Wallet seed phrase is a number too, only the “digits” it’s comprised of
+come from an alphabetically sorted series of 1626 words, the [Electrum
+wordlist][03], which begins like this:
 
 ```text
 able (0), about (1), above (2), abuse (3), accept (4) ...

+ 7 - 7
doc/wiki/using-mmgen/Subwallets.md → doc/wiki/using-mmgen-wallet/Subwallets.md

@@ -1,11 +1,11 @@
 ### Introduction
 
-Beginning with Version 0.11.0, every MMGen wallet has a two sets of
+Beginning with MMGen Wallet Version 0.11.0, every wallet has a two sets of
 associated subwallets with “long“ and “short” seeds.
 
-An MMGen subwallet is identical to an ordinary MMGen wallet in every respect.
+MMGen subwallets are identical to ordinary MMGen wallets in every respect.
 This provides a real-world security benefit, as it prevents an attacker from
-knowing whether the wallet is indeed a subwallet, i.e. whether it has a parent
+knowing whether a wallet is indeed a subwallet, i.e. whether it has a parent
 from which it was derived. 
 
 Subwallets are specified by a “Subseed Index” consisting of:
@@ -69,16 +69,16 @@ $ mmgen-walletconv -qS -o words 3E885EC4-ABCDEF00[128,3].mmdat
 peaceful marry wrong surround treasure sort use favorite enough wolf suspend path
 ```
 
-Since wallets generated by `mmgen-subwalletgen` are just ordinary wallets, you
-can use them anywhere you’d use an ordinary MMGen wallet.
+Since subwallets generated by `mmgen-subwalletgen` are just ordinary MMGen
+wallets, you can use them anywhere you’d use the latter.
 
 Being ordinary wallets, subwallets may be used to generate other subwallets in
 turn, leading to hierarchies of arbitrary depth.  However, this is inadvisable
 in practice for two reasons:  Firstly, it creates accounting complexity,
 requiring the user to independently keep track of a derivation tree.  More
 importantly, however, it leads to the danger of Seed ID collisions between
-subseeds at different levels of the hierarchy, as MMGen checks and avoids ID
-collisions only among sibling subseeds and their parent.
+subseeds at different levels of the hierarchy, as the software checks and avoids
+ID collisions only among sibling subseeds and their parent.
 
 An exception to this caveat would be a multi-user setup where sibling subwallets
 are distributed to different users as their default wallets.  Since the subseeds

+ 28 - 21
doc/wiki/using-mmgen/Test-Suite.md → doc/wiki/using-mmgen-wallet/Test-Suite.md

@@ -2,16 +2,16 @@
 
 In addition to low-level subsystems, the suite tests the overall operation of
 MMGen’s commands by running them interactively as a user would.  Thus the test
-suite is useful not only for ensuring the MMGen system is correctly installed
-and working on your platform but also for learning how it works.
+suite is useful not only for ensuring the MMGen Wallet system is correctly
+installed and working on your platform but also for demonstrating how it works.
 
-BTC-only testing requires only Bitcoin Core to be installed.  Altcoin testing
-requires various helper programs and libraries.  Installation instructions for
-these are provided below.  Non-standard RPC ports and data directories are
-always used, so there’s no need to stop your running node or nodes.
+BTC-only testing requires installation of Bitcoin Core and pycoin only, while
+altcoin testing requires additional helper programs and libraries, installation
+instructions for which are provided below.  Non-standard RPC ports and data
+directories are always used, so there’s no need to stop any running nodes.
 
 On Linux/x86\_64 with a reasonably fast processor, the full suite should run in
-under 15 minutes when invoked with the `-F` option.  Execution times on other
+under 20 minutes when invoked with the `-F` option.  Execution times on other
 platforms may be much slower.
 
 ## Quick start
@@ -63,7 +63,13 @@ $ python3 -m pip download pycoin # online
 $ python3 -m pip install --user --no-build-isolation pycoin-*.tar.gz # offline
 ```
 
-CD to the MMGen repository root and build without installing:
+Install Pylint:
+
+```text
+$ python3 -m pip install --user pylint
+```
+
+CD to the MMGen Wallet repository root and build without installing:
 
 ```text
 $ cd path/to/mmgen/repo
@@ -73,7 +79,7 @@ $ python3 setup.py build_ext --inplace
 Run the following if upgrading from a previous version of MMGen:
 
 ```text
-$ test/test.py clean
+$ test/cmdtest.py clean
 ```
 
 Run the test suite in fast mode, skipping altcoin tests:
@@ -89,9 +95,9 @@ Complete the BTC-only installation steps above, without running the test.
 Make sure the [Bitcoin Cash Node][cnd], [Litecoin][ld] and [Monero][md]
 daemons are installed on your system.
 
-Install [OpenEthereum, Parity, Geth, the Ethereum dependencies][oe] and
-optionally the [Solidity compiler][sc] as described on the
-Altcoin-and-Forkcoin-Support page.
+Install [Parity, Geth and the ETH Python requirements][oe], optionally the
+[Solidity compiler][sc], and [the XMR Python requirements][xr] as described on
+the Altcoin-and-Forkcoin-Support page.
 
 In addition, you must install the following helper programs and libraries (MSYS2
 users can omit Zcash-Mini and leave out `sudo` in commands):
@@ -110,8 +116,8 @@ system32> net user administrator /active:yes
 system32> C:\\msys64\usr\bin\bash.exe --login
 ```
 
-Now, at the MSYS2 prompt, cd to the MMGen repository root and run the setup
-script:
+Now, at the MSYS2 prompt, cd to the MMGen Wallet repository root and run the
+setup script:
 
 ```text
 $ scripts/msys2-sshd-setup.sh
@@ -196,10 +202,10 @@ The test scripts themselves are all located in the `test/` directory and bear
 the `.py` extension.  They may be run individually if desired.  Options and
 arguments required by the tests are described in detail on their help screens.
 
-High-level testing of the MMGen system is performed by `test/test.py`, which
-uses the `pexpect` library to simulate interactive operation of MMGen user
-commands.  Running `test/test.py` with the `-e` option will display the
-commands’ output on the screen as they’re being run.
+High-level testing of the MMGen Wallet system is performed by `test/cmdtest.py`,
+which uses the `pexpect` library to simulate interactive operation of MMGen
+Wallet’s user commands.  Running `test/cmdtest.py` with the `-e` option will
+display the commands’ output on the screen as they’re being run.
 
 | Test                  | What it tests                                        |
 |:----------------------|:-----------------------------------------------------|
@@ -209,17 +215,18 @@ commands’ output on the screen as they’re being run.
 | `test/objtest.py`     | MMGen data objects - creation and error handling     |
 | `test/objattrtest.py` | MMGen data objects - immutable attributes            |
 | `test/scrambletest.py`| HMAC scramble strings used in key/password derivation|
-| `test/test.py`        | overall operation of MMGen commands                  |
+| `test/cmdtest.py`     | overall operation of MMGen Wallet commands           |
 | `test/tooltest.py`    | the `mmgen-tool` utility - overall operation         |
 | `test/tooltest2.py`   | the `mmgen-tool` utility - data validity             |
 | `test/unit_tests.py`  | low-level subsystems                                 |
 
-[sd]: Install-Bitcoind-from-Source-on-Debian-or-Ubuntu-Linux
+[sd]: Install-Bitcoind-from-Source-on-Linux
 [bd]: Install-Bitcoind
 [md]: https://getmonero.org/downloads/#linux
 [ad]: https://download.bitcoinabc.org/
 [cnd]: https://bitcoincashnode.org/
 [ld]: https://download.litecoin.org/litecoin-0.17.1/
-[oe]: Altcoin-and-Forkcoin-Support#a_oe
+[oe]: Altcoin-and-Forkcoin-Support#a_ed
 [sc]: Altcoin-and-Forkcoin-Support#a_dt
+[xr]: Altcoin-and-Forkcoin-Support#a_xmr_req
 [oz]: https://github.com/openethereum/openethereum/releases/tag/v3.1.0

+ 0 - 0
doc/wiki/using-mmgen/Tool-API.md → doc/wiki/using-mmgen-wallet/Tool-API.md


+ 3 - 3
doc/wiki/using-mmgen/Tracking-and-spending-ordinary-Bitcoin-addresses.md → doc/wiki/using-mmgen-wallet/Tracking-and-spending-ordinary-Bitcoin-addresses.md

@@ -1,8 +1,8 @@
 ## Tracking and spending ordinary Bitcoin (non-MMGen) addresses
 
-While not recommended, it is possible to use MMGen to track and spend ordinary
-Bitcoin addresses too, i.e. addresses whose keys you control but which haven’t
-been spent to your MMGen wallet.
+While not recommended, it is possible to use MMGen Wallet to track and spend
+ordinary Bitcoin addresses too, i.e. addresses whose keys you control but which
+were not generated by MMGen wallet.
 
 #### Import the Bitcoin addresses for tracking (online computer):
 

+ 6 - 7
doc/wiki/using-mmgen/XOR-Seed-Splitting-Theory-and-Practice.md → doc/wiki/using-mmgen-wallet/XOR-Seed-Splitting-Theory-and-Practice.md

@@ -237,12 +237,11 @@ unique, and differ from their non-master-share counterparts.
 
 ### <a id="a_ss">Seed Splitting with MMGen</a>
 
-The MMGen wallet implements the seed splitting and joining functionality
-described above via the commands [`mmgen-seedsplit`][SS] and
-[`mmgen-seedjoin`][SJ].  Usage examples can be found on the `mmgen-seedsplit`
-help screen.
+MMGen Wallet implements the seed splitting and joining functionality described
+above via the commands [`mmgen-seedsplit`][SS] and [`mmgen-seedjoin`][SJ].
+Usage examples can be found on the `mmgen-seedsplit` help screen.
 
-Shares can be made from and exported to all supported MMGen wallet formats.
+Shares can be made from and exported to all supported MMGen Wallet formats.
 This means you can split a BIP39 seed phrase, for example, and output the share
 back to BIP39 in one easy command:
 
@@ -311,8 +310,8 @@ Unfortunately, rejoining master-share splits is considerably harder to do at
 the Python command prompt.  This is because converting the master share into the
 temporary share used to make the split involves an additional step, as you’ll
 recall from the above discussion.  In addition, this step is implemented by
-MMGen somewhat differently than as described above.  For advanced users, an
-example will be provided in a future version of this document.
+MMGen Wallet somewhat differently than as described above.  For advanced users,
+an example will be provided in a future version of this document.
 
 [⊕]: https://mmgen.github.io/images/ss/o_xor.svg "⊕"
 ["a: 1 0 0 1 0 1 0 0"]: https://mmgen.github.io/images/ss/byte_a.svg "a: 1 0 0 1 0 1 0 0"

+ 1 - 1
mmgen/data/version

@@ -1 +1 @@
-14.0.dev19
+14.0.dev20

+ 13 - 13
mmgen/help/__init__.py

@@ -134,7 +134,7 @@ data from a multi-line file with free spacing and indentation.
 			return """
 BRAINWALLET NOTE:
 
-To thwart dictionary attacks, it's recommended to use a strong hash preset
+To thwart dictionary attacks, its recommended to use a strong hash preset
 with brainwallets.  For a brainwallet passphrase to generate the correct
 seed, the same seed length and hash preset parameters must always be used.
 """.strip()
@@ -213,21 +213,21 @@ as described above for the change output.
 Transactions may contain both {pnm} or non-{pnm} input addresses.
 
 To sign non-{pnm} inputs, a {wd}flat key list is used
-as the key source ('--keys-from-file' option).
+as the key source (--keys-from-file option).
 
 To sign {pnm} inputs, key data is generated from a seed as with the
 {pnl}-addrgen and {pnl}-keygen commands.  Alternatively, a key-address file
 may be used (--mmgen-keys-from-file option).
 
 Multiple wallets or other seed files can be listed on the command line in
-any order.  If the seeds required to sign the transaction's inputs are not
+any order.  If the seeds required to sign the transactions inputs are not
 found in these files (or in the default wallet), the user will be prompted
 for seed data interactively.
 
 To prevent an attacker from crafting transactions with bogus {pnm}-to-{pnu}
 address mappings, all outputs to {pnm} addresses are verified with a seed
 source.  Therefore, seed files or a key-address file for all {pnm} outputs
-must also be supplied on the command line if the data can't be found in the
+must also be supplied on the command line if the data cant be found in the
 default wallet.
 """.format(
 	wd  = (f'{coind_exec()} wallet dump or ' if isinstance(proto,mainnet) else ''),
@@ -240,21 +240,21 @@ default wallet.
 			return f"""
 SUBWALLETS:
 
-Subwallets (subseeds) are specified by a "Subseed Index" consisting of:
+Subwallets (subseeds) are specified by a ‘Subseed Index’ consisting of:
 
   a) an integer in the range 1-{SubSeedIdxRange.max_idx}, plus
-  b) an optional single letter, 'L' or 'S'
+  b) an optional single letter, ‘L’ or ‘S’
 
-The letter designates the length of the subseed.  If omitted, 'L' is assumed.
+The letter designates the length of the subseed.  If omitted, ‘L’ is assumed.
 
-Long ('L') subseeds are the same length as their parent wallet's seed
-(typically 256 bits), while short ('S') subseeds are always 128-bit.
+Long (‘L’) subseeds are the same length as their parent wallet’s seed
+(typically 256 bits), while short (‘S’) subseeds are always 128-bit.
 The long and short subseeds for a given index are derived independently,
 so both may be used.
 
-MMGen has no notion of "depth", and to an outside observer subwallets are
-identical to ordinary wallets.  This is a feature rather than a bug, as it
-denies an attacker any way of knowing whether a given wallet has a parent.
+MMGen Wallet has no notion of ‘depth’, and to an outside observer subwallets
+are identical to ordinary wallets.  This is a feature rather than a bug, as
+it denies an attacker any way of knowing whether a given wallet has a parent.
 
 Since subwallets are just wallets, they may be used to generate other
 subwallets, leading to hierarchies of arbitrary depth.  However, this is
@@ -267,7 +267,7 @@ MMGen checks and avoids ID collisions only among sibling subseeds.
 An exception to this caveat would be a multi-user setup where sibling
 subwallets are distributed to different users as their default wallets.
 Since the subseeds derived from these subwallets are private to each user,
-Seed ID collisions among them doesn't present a problem.
+Seed ID collisions among them doesnt present a problem.
 
 A safe rule of thumb, therefore, is for *each user* to derive all of his/her
 subwallets from a single parent.  This leaves each user with a total of two

+ 4 - 4
mmgen/help/xmrwallet.py

@@ -242,10 +242,10 @@ removable device on it.  And this is the whole point of autosigning: to make
 cold signing as convenient as possible, almost like transacting with a hot
 wallet.
 
-If your signing machine is an SoC with MMGen LED support (see ‘mmgen-autosign
---help’), a quickly flashing LED will indicate that signing is in progress, a
-slowly flashing LED an error condition, and no LED that the program is idle
-and waiting for device insertion.
+If your signing machine is an SoC with MMGen Wallet LED support (see
+‘mmgen-autosign --help’), a quickly flashing LED will indicate that signing
+is in progress, a slowly flashing LED an error condition, and no LED that the
+program is idle and waiting for device insertion.
 
 On your online machine, start monerod, wait until it’s fully synced with the
 network, insert the removable device and execute:

+ 2 - 2
mmgen/opts.py

@@ -154,8 +154,8 @@ class UserOpts:
 		from .util import Die,fmt
 		Die(0,fmt(f"""
 			{gc.prog_name.upper()} version {gc.version}
-			Part of the {gc.proj_name} suite, an online/offline cryptocurrency wallet for the
-			command line.  Copyright (C){gc.Cdates} {gc.author} {gc.email}
+			Part of {gc.proj_name} Wallet, an online/offline cryptocurrency wallet for the
+			command line. Copyright (C){gc.Cdates} {gc.author} {gc.email}
 		""",indent='  ').rstrip())
 
 	def print_help(self,cfg):