mmgen/mmgen-wallet
1
Fork 0
Code Releases 28 Wiki Activity

documentation: MMGen -> MMGen Wallet

Browse source
This commit is contained in:
The MMGen Project 2023-11-16 16:02:49 +00:00
commit b9a443fe8a
Signed by: mmgen
GPG key ID: 3F8B1861E32B7DA2
21 changed files with 506 additions and 480 deletions
Download patch file Download diff file Expand all files Collapse all files

109
README.md
View file

@ -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

5
doc/README.mswin.md
View file

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

11
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
View file

@ -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:

6
doc/wiki/install-linux/Install-Bitcoind.md
View file

@ -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
doc/wiki/install-linux/Install-MMGen-Wallet-on-Linux.md Normal file
View file

@ -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

107
doc/wiki/install-linux/Install-MMGen-on-Linux.md
View file

@ -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

6
doc/wiki/install-mswin/Install-Bitcoind.md
View file

@ -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
doc/wiki/install-mswin/Install-MMGen-on-Microsoft-Windows.md → doc/wiki/install-mswin/Install-MMGen-Wallet-on-Windows.md
View file

81
doc/wiki/using-mmgen/Altcoin-and-Forkcoin-Support.md → doc/wiki/using-mmgen-wallet/Altcoin-and-Forkcoin-Support.md
View file

@ -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

392
doc/wiki/using-mmgen/Getting-Started-with-MMGen.md → doc/wiki/using-mmgen-wallet/Getting-Started-with-MMGen-Wallet.md
View file

@ -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 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 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’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`.
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`.
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.
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.
If you’ve deleted or lost your local copy of the MMGen repository, clone it
again from Github or Gitlab:
##### <a id="a_uds">Stable version:</a>
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:
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].
Now build and install:
```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].
Check the latest release notes in `doc/release-notes` and make note of any new
features or requirements. 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

16
doc/wiki/using-mmgen/MMGen-Quick-Start-with-Regtest-Mode.md → doc/wiki/using-mmgen-wallet/MMGen-Wallet-Quick-Start-with-Regtest-Mode.md
View file

@ -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

24
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
View file

@ -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) ...

14
doc/wiki/using-mmgen/Subwallets.md → doc/wiki/using-mmgen-wallet/Subwallets.md
View file

@ -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

49
doc/wiki/using-mmgen/Test-Suite.md → doc/wiki/using-mmgen-wallet/Test-Suite.md
View file

@ -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
doc/wiki/using-mmgen/Tool-API.md → doc/wiki/using-mmgen-wallet/Tool-API.md
View file

6
doc/wiki/using-mmgen/Tracking-and-spending-ordinary-Bitcoin-addresses.md → doc/wiki/using-mmgen-wallet/Tracking-and-spending-ordinary-Bitcoin-addresses.md
View file

@ -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):

13
doc/wiki/using-mmgen/XOR-Seed-Splitting-Theory-and-Practice.md → doc/wiki/using-mmgen-wallet/XOR-Seed-Splitting-Theory-and-Practice.md
View file

@ -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"

2
mmgen/data/version
View file

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

26
mmgen/help/__init__.py
View file

@ -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, it’s 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 transaction’s 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 can’t 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 doesn’t 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

8
mmgen/help/xmrwallet.py
View file

@ -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:

4
mmgen/opts.py
View file

@ -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):