Edgecase | Generating a standard Bitcoin address

Goal

I want to generate a standard Bitcoin address.

This will involve:
- describing the address format
- generating an address and sending some bitcoin to it

For this project, I'm defining a "standard" address to be an uncompressed single-signature Pay-To-Public-Key-Hash (P2PKH) address.

Contents

- Goal
- Contents
- Brief Summary
- Summary
- Bitcoin Address Generation Recipe
- Downloadable Assets
- Representative Sample Of Bash Commands Used
- Notes / Discoveries
- Project Log

Brief Summary

Summary

In this project, I succeeded in:
1) creating a private key
2) generating the corresponding Bitcoin address
3) sending bitcoin to this address
4) generating the private key in WIF form
5) retrieving bitcoin from this address using the private key in WIF form

For item (1):
- I found and read documentation about secp256k1, the elliptic curve used in the Bitcoin cryptosystem. I was able to confirm to my satisfaction the domain of valid Bitcoin private keys. A valid Bitcoin private key lies in the closed interval [1, n-1], where the hex value of n = FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFE BAAEDCE6 AF48A03B BFD25E8C D0364141. This documentation is available in the Downloadable Assets section, as "sec2_v2.pdf" and "x9_62_draft_ecdsa.pdf". I have included a subset of this elliptic curve information in the Notes / Discoveries section, in the part named "Some notes on elliptic curves, particularly secp256k1".
- I chose a private key manually ("hello_world"). In normal practice, it is much more secure to generate some entropy (e.g. by using dice) with which to choose a private key.

For item (2):
- I used a guide for encoding a Bitcoin address that I found on a Bitcoin-focused wiki. I wrote my own version of the information in this guide - it can be found in the Notes / Discoveries section, in the parts named "Algorithm for generating a Bitcoin address" and "Base-58 conversion table".
-- In items (3), (4), and (5), I confirmed that the information in this guide was valid (for at least one case) by moving bitcoin into and out of a generated address.
- I studied a Python implementation of ECDSA. Eventually I learned how to use this code to calculate an ECDSA public key from an ECDSA private key.
- I performed the steps for deriving a Bitcoin address from a valid Bitcoin private key. Later, I developed Python code that automated this process. This code is available in the Downloadable Assets section as "generate_bitcoin_address.py". Please see the Bitcoin Address Generation Recipe section for instructions on how to use it.

For item (3):
- I used a webwallet on the LocalBitcoins system to send some bitcoin to the generated address.
- Note: LocalBitcoins charged a transaction fee.

For item (4):
- I used a guide for encoding a private key in WIF form that I found on a second Bitcoin-focused wiki. I wrote my own version of the information in this guide - it can be found in the Notes / Discoveries section, in the part named "Algorithm for generating the WIF (Wallet Import Format) form of a private key".
-- In item (5), I confirmed that the information in this guide was valid (for at least one case) by moving bitcoin out of a generated address that corresponded to this private key.
- I performed the steps for encoding a Bitcoin private key in WIF form. Later, I developed Python code to automate these steps - this code forms part of the "generate_bitcoin_address.py" asset.

For item (5):
- I created a virtual machine instance on Digital Ocean, on which I:
-- downloaded the GPG key of the Electrum author (Thomas Voegtlin)
-- downloaded Electrum 3.1.3 tarball and signature
-- used GPG 2.1.18 (pre-installed by Digital Ocean) to verify the signature of the tarball.
-- installed some dependencies for Electrum 3.1.3 (using the APT package manager)
-- installed Electrum 3.1.3
-- used Electrum to:
--- a) create and sign a transaction that would move bitcoin out of the generated address and send it to my LocalBitcoins receiving address. To accomplish this, Electrum required access to the private key in WIF form of the generated address.
--- b) broadcast this transaction to the dedicated Electrum servers. After a short time (less than 30 minutes), this transaction was mined (included in the Bitcoin blockchain). Note: This transaction included a mining fee set by Electrum (in turn set by the dedicated Electrum servers, I think).
- Note: LocalBitcoins charged a deposit fee.
- Thomas Voegtlin's GPG key and the Electrum 3.1.3 tarball and signature are included in the Downloadable Assets section. I have not included GPG 2.1.18 or the various dependencies of Electrum.

For further details, please see the Notes / Discoveries section, particularly the first part, named "Notes on the nature, secure creation, and validity of Bitcoin private keys and transactions".

The private key:
hello_world

The private key in hex bytes:
68656c6c6f5f776f726c64

The 32-byte private key in hex bytes:
00000000000000000000000000000000000000000068656c6c6f5f776f726c64

The ECDSA public key (64 bytes, with a "04" byte at the front to indicate that the key is uncompressed):
043cd69b03d4bbbdc07450a36de99e792aaaf00298076d0daa761450156bb9c1b75a72839ce8c498f55fbb69312a661d3572c250e26a0189ae068ef50abc68d3e7

The generated Bitcoin address:
19VdGCFG8QH3CmYXjMXd3UQCK2HdC3UodP

The private key in WIF form:
5HpHagT65TZzG1PH3CSu63k8DbpvD8v17zAxKbSJNTwsxtFHvZK

The originating address for the first transaction (that moved bitcoin into the generated address):
3Pq6moLEDjtwEVM6mWo3nPGGjem3VFEMNo

The transaction id of the first transaction is:
e611dfee1e1cb3e0ec1097f19a0012e801fdd0873c7342674f37234f999f77f2

0.001 bitcoin was sent to the generated Bitcoin address. LocalBitcoins charged a separate transaction fee of 0.00005 bitcoin (this didn't affect the amount that was actually sent).

The transaction id of the second transaction (that moved bitcoin out of the generated address) is:
55cef237815986b3bebd602154c01592710f77213f7c9718b991b4b8e19b9954

The LocalBitcoins receiving address:
1GgW5oTD3nFnEsGqXUdu61gksi8ohzXmaN

0.00099552 bitcoin was sent to the LocalBitcoins receiving address.

The transaction fee was 0.00000448 bitcoin. Electrum originally suggested that the transaction fee would be 0.00002227 bitcoin - I don't know why the actual fee was significantly smaller.

LocalBitcoins charged a deposit fee of 0.00015000 bitcoin.

For this project, I spent a total of
[LocalBitcoins transaction fee] + [Electrum/Bitcoin_network transaction fee] + [LocalBitcoins deposit fee] =
0.00005000 + 0.00000448 + 0.00015000 = 0.00020448 bitcoin.

I sent 0.001 bitcoin and retrieved
0.001 - (0.00000448 + 0.00015000) = 0.00084552 bitcoin.

Bitcoin Address Generation Recipe

Create or generate a private key in raw byte form. This could be a string of printable ASCII letters or words selected by, for example, throwing dice. If you want to use byte values that are not printable ASCII characters, you can record the private key in hex bytes.

Example private key in raw byte form: hello_world
The same private key in hex bytes: 68656c6c6f5f776f726c64

Create a new project directory. In this recipe, this directory will be named "the work directory".

From the links in the Downloadable Assets section, download the following assets and save them in the work directory:
- bjorn_edstrom_ripemd160.py
- ecdsa-0.10.tar.gz
- pypy_sha256.py
- generate_bitcoin_address.py

Unpack the zipped tape archive file ecdsa-0.10.tar.gz file. The following command can be used to do this:

tar -zxvf ecdsa-0.10.tar.gz

The unpacking should produce a new directory: ecdsa-0.10

ecdsa-0.10 should contain a directory named: ecdsa

Copy the ecdsa directory to the work directory. The ecdsa library can now be imported by the generate_bitcoin_address.py script.

Future: Investigate how the generate_bitcoin_address.py could import the ecdsa library directly, so that the copy operation above is not necessary.

Open the generate_bitcoin_address.py file in a text editor.

Set the value of the variable

private_key_bytes

to be the private key in raw byte form that you generated earlier.

Alternatively, if you chose to record the private key in hex bytes, change line 36 (note: lines are 1-indexed) to be this:

private_key_hex = "68656c6c6f5f776f726c64"

Make sure that it is indented by 1 tab. Set its value to the private key hex byte value that you created earlier.

Run the script generate_bitcoin_address.py. Note that it was developed under Python 2.7.13. It will hopefully run under other Python 2.7.x versions.

If you followed the earlier instructions to change the script so that you could set the input to be the private key in hex bytes, ignore the first line of the output, which will be something like:

- INPUT: private_key_bytes: hello_world

You should see output similar to this:

aineko:work stjohnpiano$ python generate_bitcoin_address.py

- INPUT: private_key_bytes: hello_world
- private_key_hex: 68656c6c6f5f776f726c64
- 32-byte private_key_hex: 00000000000000000000000000000000000000000068656c6c6f5f776f726c64
- private key lies within input domain of secp256k1 elliptic curve.
- private_key_WIF: 5HpHagT65TZzG1PH3CSu63k8DbpvD8v17zAxKbSJNTwsxtFHvZK
- public_key_hex: 043cd69b03d4bbbdc07450a36de99e792aaaf00298076d0daa761450156bb9c1b75a72839ce8c498f55fbb69312a661d3572c250e26a0189ae068ef50abc68d3e7
- Bitcoin address: 19VdGCFG8QH3CmYXjMXd3UQCK2HdC3UodP

This Bitcoin public address is now ready for use. Please bear in mind that:
- If you want to actually use a Bitcoin address generated by this script, you should a) run it on an offline computer, b) copy the private key onto multiple paper backups, and c) delete the private key from the offline computer.
- In order to be absolutely certain of the validity of this address, a transaction from it should be signed offline and accepted into the Bitcoin blockchain, proving that any bitcoin sent to it can be retrieved. The private key is used to make the signature, so signing the transaction offline means that the private key will never need to be on an Internet-connected computer.

I recommend that you read the first part ("Notes on the nature, secure creation, and validity of Bitcoin private keys and transactions") of the Notes / Discoveries section of this article before using this recipe.

Downloadable Assets

Documentation concerning ECDSA elliptic curves.

Title: Standards for Efficient Cryptography, SEC 2: Recommended Elliptic Curve Domain Parameters, Version 2.0
Author: Daniel R. L. Brown, Certicom Research
Date: January 27, 2010
sec2_v2.pdf

Title: Working Draft, American National Standard, X9.62-1998, Public Key Cryptography For The Financial Services Industry: The Elliptic Curve Digital Signature Algorithm (ECDSA)
Author: Accredited Standards Committee X9, American Bankers Association.
Date: September 20, 1998
x9_62_draft_ecdsa.pdf

I originally found sec2_v2.pdf at:
www.secg.org/sec2-v2.pdf

It was linked from:
bitcoin.org/en/developer-guide

I originally found x9_62_draft_ecdsa.pdf at:
citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.202.2977&rep=rep1&type=pdf

Its name ("X9.62-1998 (draft)") was mentioned in the Python ECDSA library.

Electrum 3.1.3, with signature and author's public key.
Author: Thomas Voegtlin
Note: Electrum 3.1.3 requires various dependencies, not included here, which were installed in this project through the use of a package management system on a rented virtual machine. The output in the Project Log may be useful for anyone trying to map Electrum's dependencies.

electrum-3.1.3.tar.gz

electrum-3.1.3.tar.gz.asc

thomas_voegtlin_public_key.txt

The following links are to assets of a previous article (Reading and verifying a standard raw bitcoin transaction).

bjorn_edstrom_ripemd160.py [paywalled]

ecdsa-0.10.tar.gz [paywalled]

pypy_sha256.py [paywalled]

Notes on the authorship of the previous three assets:

- bjorn_edstrom_ripemd160.py is a Python implementation of RIPEMD-160, written by Björn Edström, published 16 December 2007. I downloaded it on 2017-08-04.

- ecdsa-0.10.tar.gz is a Python implementation of ECDSA cryptography, written by Peter Pearson, published in 2005. Some comments/updates in the code are dated 2006, 2008, and 2009. Brian Warner added a wrapper around the original code in 2010. I downloaded it while writing the article to which it is attached as an asset.

- pypy_sha256.py is a Python implementation of SHA256. I don't know who the author is. I downloaded it on 2017-05-12.

The next linked asset is a script that generates a standard Bitcoin address from a private key in raw byte form (e.g. "hello_world"). It uses the previous three assets as dependencies. I developed it under Python 2.7.13 running on Mac OS X 10.6.8. It also generates the private key in WIF form and the public key in hex bytes, and checks that the private key lies within the input domain of the secp256k1 elliptic curve used in the Bitcoin cryptosystem.

generate_bitcoin_address.py

Representative Sample Of Bash Commands Used

Note: The output of many of these commands is not included.

[show the path to the working directory]

root@test1:~# pwd

/root

[change directory to the path '/home']

root@test1:~# cd /home

[create a new directory named 'work']

root@test1:/home# mkdir work

[list items in the current directory, one line per item]

root@test1:/home/work# ls -1

[download a .tar.gz file]

root@test1:/home/work# wget http://download.electrum.org/3.1.3/Electrum-3.1.3.tar.gz

[import a public key]

root@test1:~# gpg --import thomasv.public_key

[verify the signature of the .tar.gz file]

root@test1:/home/work# gpg --verify Electrum-3.1.3.tar.gz.asc Electrum-3.1.3.tar.gz

[Unpack the zipped tape archive file]

root@test1:/home/work# tar -zxvf Electrum-3.1.3.tar.gz

[check the version of the APT package manager]

root@test1:/home/work/Electrum-3.1.3# apt-get --version

[show the value of the PATH variable]

root@test1:/home/work/Electrum-3.1.3# echo $PATH

/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

[add a directory path to the PATH variable]

root@test1:/home/work/Electrum-3.1.3# export PATH=$PATH:/root/.local/bin

[change a Python script's permissions so that it becomes executable]

aineko:work stjohnpiano$ chmod 700 generate_bitcoin_address.py

[run the executable Python script]

aineko:work stjohnpiano$ ./generate_bitcoin_address.py

[check equality of two strings]

aineko:work stjohnpiano$ s1="68656c6c6f5f776f726c64"

aineko:work stjohnpiano$ s2="68656c6c6f5f776f726c64"

aineko:work stjohnpiano$ [[ "$s1" = "$s2" ]] && echo equal || echo not-equal

equal

[log in via ssh to machine listening at a particular IP address]

aineko:~ stjohnpiano$ ssh root@167.99.188.209

[log in via ssh to a machine listening at a particular IP address that is connected to a particular domain]

aineko:~ stjohnpiano$ ssh root@edgecase-test.net

[log out of a machine to which you have connected via ssh]

root@test1:~# exit

logout
Connection to edgecase-test.net closed.

Notes / Discoveries

Parts:
- Notes on the nature, secure creation, and validity of Bitcoin private keys and transactions
- Bitcoin capitalisation conventions
- Algorithm for generating a Bitcoin address
- Base-58 conversion table
- Algorithm for generating the WIF (Wallet Import Format) form of a private key
- Some notes on elliptic curves, particularly secp256k1

Notes on the nature, secure creation, and validity of Bitcoin private keys and transactions:

1) A Bitcoin private key (a sequence of 256 bits - the value of a bit can be either 0 or 1) is related mathematically to a corresponding Bitcoin public address. The address can be shown or given to anyone else. Bitcoin is stored on a public distributed ledger (a database that associates Bitcoin amounts with public addresses). The private key must be kept secret, as it allows anyone who knows it to spend the bitcoin associated with it. Spending bitcoin is accomplished via the creation and broadcasting of transactions. Transactions can be thought of as digitally signed patches that alter the state of the Bitcoin public ledger.
Note: A Bitcoin private key must be in the closed interval [1, n-1] where n is the order of the base point G of the elliptic curve secp256k1. In hex, n = FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFE BAAEDCE6 AF48A03B BFD25E8C D0364141. n is 32 bytes (256 bits) long. Most, but not all, 256-bit sequences are valid Bitcoin private keys.

2) A quantity of entropy (some information without predictable structure) should be generated in order to create the private key. If this is done properly, it is extremely difficult for an attacker to guess the private key. This entropy can be used to select:
- bit values (0 or 1), which can be recorded as bytes in hex form.
- ASCII characters.
- words formed from ASCII characters.
See the article How I bought and stored some bitcoin [paywalled] for an example of creating entropy, using it to select words to make a passphrase, and storing the resulting passphrase in paper notebooks.

3) In order to keep the private key secret, it should never be stored, however temporarily, on a computer connected:
- To the Internet
- To any kind of electronic network. From what I understand, this includes any electrical power system. Ideally, the offline computer should run on batteries.
A secure setup would be a soundproof room containing a Faraday cage, which itself would be large enough to contain: a person, a chair, a desk, the offline computer, a battery system, and some means of generating entropy (e.g. dice). The private keys should be copied onto multiple paper backups that can be stored outside of the Faraday cage. The private key should be deleted from the offline computer after it has been backed up onto paper. You should regard anything less than this as a security risk, but you may prefer to use less security due to lack of resources or an interest in convenience.

4) Bitcoin addresses are base58-encoded strings containing an address version number, the hash of the Bitcoin public key, and an error-detection checksum to catch typos. If you type out an address, and make a mistake, the checksum will be invalid. The Bitcoin public key is derived from the private key using ECDSA. The hash of the public key is calculated by applying the SHA256 hash algorithm to the public key and then applying the RIPEMD-160 hash algorithm to the result. So hash(public_key) == RIPEMD-160(SHA256(public_key)). The base58 symbol table used for the base58 encoding is specific to Bitcoin.

5) To be absolutely certain that an address was correctly generated from a private key, you can create a transaction that moves some or all of the bitcoin in the address to another address that you control. The transaction should then be broadcasted to a selection of Bitcoin nodes. If the transaction is mined (i.e. included in a new block in the Bitcoin blockchain), you know that the address is valid and that you can move bitcoin into and out of it. The transaction must be signed with the private key corresponding to the sending address. Therefore, in order to protect the private key, the transaction should be signed on an offline computer (e.g. the same one that was used to generate the address).

6) A transaction signature requires a significant amount of entropy. The entropy used for the signature should be generated with the same care as that which was used to generate entropy for creating the private key.
- I find this comment in ecdsa.py in the ECDSA library:
"It is absolutely vital that random_k be an unpredictable number in the range [1, self.public_key.point.order()-1]. If an attacker can guess random_k, he can compute our private key from a single signature. Also, if an attacker knows a few high-order bits (or a few low-order bits) of random_k, he can compute our private key from many signatures."
- I think that "point" means the point that defines the public key, not the base point G of the secp256k1 elliptic curve, but I am not certain. Learning how to find the maximum value of random_k will require further work.
- This random integer should be only ever be used for a single signature. It is not required for signature verification, so once the signature has been created, I think the random integer can be discarded.

Bitcoin capitalisation conventions:
- Capitalise the word "Bitcoin" when referring to the technology / network / cryptosystem.
Example: "The Bitcoin network is performing X hash operations per second."
Example: "I have set up a Bitcoin node."
- Leave the word "bitcoin" in lowercase when referring to the unit of account in the Bitcoin cryptosystem.
Example: "This computer costs X bitcoin."
- There is an edge case when the unit-of-account word "bitcoin" appears at the beginning of a sentence and is therefore capitalised.
Example: "Bitcoin to be sent to seller: X"

Algorithm for generating a Bitcoin address:

1) Create an ECDSA private key. Add leading zero bytes until it is 256 bits (32 bytes) long.

This private key must be in the closed interval [1, n-1] where n is the order of the base point G of the elliptic curve secp256k1. In hex, n = FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFE BAAEDCE6 AF48A03B BFD25E8C D0364141. n is 32 bytes (256 bits) long. Most, but not all, 256-bit sequences are valid Bitcoin private keys.

2) Generate the corresponding ECDSA public key.

3) Hash the public key using the SHA256 algorithm.

4) Hash the result of step (3) using the RIPEMD-160 algorithm.

5) Add the version byte in front of the result of step (4). For the main Bitcoin network, the version byte is 0x00. Another way to describe this step is: Bytewise concatenate the version byte and the result of step (4).

6) Hash the result of step (5) using the SHA256 algorithm.

7) Hash the result of step (6) using the SHA256 algorithm.

8) Select the first four bytes of step (7).

9) Bytewise concatenate the result of step (5) and step (8).

10) Treating the result of step (9) as a single big-endian bignumber, convert it to base-58 using bignumber division. This result should not have any leading zeros.

11) Count the number of leading zeros in the result of step (5).

12) Let the result of step (11) be N. Add N '1' characters in front of the result of step (10). Each of these represents a leading zero byte that was not preserved in step (10).

Steps 6-12 comprise the Base58Check algorithm.

Algorithm for step (10):
- Convert the byte sequence to a big integer. How this is done will depend on the programming language. The result must be stored in a big integer data type upon which a division operation can be performed.
- Set a result string R to be an empty string.
- Repeatedly divide the big integer by 58. Using the base-58 conversion table (below), convert the remainder of each division into a base-58 symbol. Append this symbol to the end of R. Stop when the result is 0.
- Reverse the result string R.
- Note: It would be possible to prepend to the beginning of R instead of appending, and thus have no need to reverse R at the end, but prepending is usually a slower operation than appending.

Base-58 conversion table:

Remainder Value => Base-58 Symbol

0 => 1
1 => 2
2 => 3
3 => 4
4 => 5
5 => 6
6 => 7
7 => 8
8 => 9
9 => A
10 => B
11 => C
12 => D
13 => E
14 => F
15 => G
16 => H
17 => J
18 => K
19 => L
20 => M
21 => N
22 => P
23 => Q
24 => R
25 => S
26 => T
27 => U
28 => V
29 => W
30 => X
31 => Y
32 => Z
33 => a
34 => b
35 => c
36 => d
37 => e
38 => f
39 => g
40 => h
41 => i
42 => j
43 => k
44 => m
45 => n
46 => o
47 => p
48 => q
49 => r
50 => s
51 => t
52 => u
53 => v
54 => w
55 => x
56 => y
57 => z

Notably, the symbol used to indicate "0" in this base58 encoding is "1".

Satoshi Nakamoto's reasoning for his particular choice of base58 encoding:
- Why base-58 instead of standard base-64 encoding?
-- Don't want 0OIl characters that look the same in some fonts and could be used to create visually identical looking account numbers.
-- A string with non-alphanumeric characters is not as easily accepted as an account number.
-- E-mail usually won't line-break if there's no punctuation to break at.
-- Doubleclicking selects the whole number as one word if it's all alphanumeric.

Algorithm for generating the WIF (Wallet Import Format) form of a private key:

1) Obtain a valid private key (i.e. within the input domain of the secp256k1 elliptic curve). Add leading zero bytes until it is 256 bits (32 bytes) long.

2) Add a 0x80 byte in front of the result of step (1).

3) Hash the result of step (2) using the SHA256 algorithm.

4) Hash the result of step (3) using the SHA256 algorithm.

5) Select the first four bytes of step (4). This is the checksum.

6) Append the result of step (5) to the result of step (2).

7) Treating the result of step (6) as a single big-endian bignumber, convert it to base-58 using bignumber division.

Note: This is for uncompressed main-network addresses.

Note: The input for step (7) (i.e. the result of step (6)) should never have any leading zeros, because in step (2) a non-zero byte was used as a prefix. It's not necessary to count leading zeros and pad the final result with '1' characters.

Note: Essentially, steps 3-7 can be replaced with the Base58Check algorithm (steps 6-12) of the Bitcoin-address-generation algorithm shown earlier. The code for padding the final result with '1' characters will not have any effect.

Some notes on elliptic curves, particularly secp256k1:

Constants used in the ECDSA library:

# Certicom secp256-k1

_a  = 0x0000000000000000000000000000000000000000000000000000000000000000

_b  = 0x0000000000000000000000000000000000000000000000000000000000000007

_p  = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f

_Gx = 0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798

_Gy = 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8

_r  = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141

These match the values found in sec2_v2.pdf.

SEC stands for Standards for Efficient Cryptography.

Match variable names in ECDSA library to those in SEC 2 document:
_a = a
_b = b
_p = p
_Gx = X-value of base point G
_Gy = Y-value of base point G
_r = n

One exception: SEC 2 included the constant h = 01, which didn't appear in the ECDSA library. However, on page 15 of x9_62_draft_ecdsa.pdf, I find that "The cofactor h is not used in ECDSA, but is included here for compatibility with ANSI X9.63 [6] where it may be needed."

Full excerpt from page 9 of the SEC 2 document:

2.4.1 Recommended Parameters secp256k1

The elliptic curve domain parameters over F_p associated with a Koblitz curve secp256k1 are specified by the sextuple T = (p, a, b, G, n, h) where the finite field F_p is defined by:

p = FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFE FFFFFC2F

= 2^256 - 2^32 - 2^9 - 2^8 - 2^7 - 2^6 - 2^4 - 1

The curve E: y^2 = x^3 + ax + b over F_p is defined by:

a = 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
b = 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000007

The base point G in compressed form is:

G = 02 79BE667E F9DCBBAC 55A06295 CE870B07 029BFCDB 2DCE28D9 59F2815B 16F81798

and in uncompressed form is:

G = 04 79BE667E F9DCBBAC 55A06295 CE870B07 029BFCDB 2DCE28D9 59F2815B 16F81798 483ADA77 26A3C465 5DA4FBFC 0E1108A8 FD17B448 A6855419 9C47D08F FB10D4B8

Finally the order n of G and the cofactor are:

n = FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFE BAAEDCE6 AF48A03B BFD25E8C D0364141
h = 01

Explanation of the elliptic curve name "secp256k1":

On pages 4-5 of sec2_v2.pdf,

The recommended elliptic curve domain parameters over F_p have been given nicknames to enable them to be easily identified. The nicknames were chosen as follows. Each name begins with "sec" to denote "Standards for Efficient Cryptography", followed by a "p" to denote parameters over F_p, followed by a number denoting the length in bits of the field size "p", followed by a "k" to denote parameters associated with a Koblitz curve or an "r" to denote verifiably random parameters, followed by a sequence number.

So "secp256k1" means:
[Standards for Efficient Cryptography] + [parameters over F_p] + [length in bits of the field size "p" == 256] + [parameters are associated with a Koblitz curve] + [sequence number == 1]

Various definitions, found on pages 2, 3, and 5 of x9_62_draft_ecdsa.pdf:

elliptic curve
An elliptic curve over F_q is a set of points which satisfy a certain equation specified by 2 parameters a and b, which are elements of a field F_q. (See Section 4.2.)

elliptic curve key pair (Q, d)
Given particular elliptic curve domain parameters, an elliptic curve key pair consists of an elliptic curve public key (Q) and the corresponding elliptic curve private key (d).

elliptic curve private key (d)
Given particular elliptic curve domain parameters, an elliptic curve private key, d, is a statistically unique and unpredictable integer in the interval [1, n-1], where n is the prime order of the base point G.

elliptic curve public key (Q)
Given particular elliptic curve domain parameters, and an elliptic curve private key d, the corresponding elliptic curve public key, Q, is the elliptic curve point Q = dG, where G is the base point. Note that Q will never equal point_at_infinity, since 1 <= d <= n-1.

elliptic curve domain parameters
Elliptic curve domain parameters are comprised of a field size q, indication of basis used (in the case q = 2^m), an optional SEED, two elements a, b in F_q which define an elliptic curve E over F_q, a point G = (x_G,y_G) of prime order in E(F_q), the order n of G, and the cofactor h. See Sections 5.1.1.1 and 5.1.2.1 for a complete specification of elliptic curve domain parameters.

elliptic curve point
If E is an elliptic curve defined over a field F_q, then an elliptic curve point P is either: a pair of field elements (x_p, y_p) (where x_p, y_p element_of F_q) such that the values x = x_p and y = y_p satisfy the equation defining E, or a special point called the point_at_infinity.

order of a curve
The order of an elliptic curve E defined over the field F_q is the number of points on E, including the point_at_infinity. This is denoted by #E(F_q).

order of a point
The order of a point P is the smallest positive integer n such that nP = the point_at_infinity.

prime finite field
A finite field containing p elements, where p is an odd prime number.

h
h = #E(Fq)/n, where n is the order of the base point G. h is called the cofactor.

Key points:

- n = The prime order of the base point G
- d = The private key, in the interval [1,n-1]
- Q = The public key, found by multiplying G by d.

- Limiting d to the interval [1,n-1] means that Q will never equal the point_at_infinity.
-- Presumably, in the elliptic curve cryptosystem mathematics, Q != point_at_infinity is a necessary condition.

- F_p = A field containing p elements. If p is a fixed integer, then the field is "finite". If p is prime, the field F_p is a "prime finite field".
- An elliptic curve over a finite field F_p is denoted by E(F_p).
- The "order of an elliptic curve", denoted by #E(F_p), is the number of points on the curve. This includes the point_at_infinity.

- The "order of a point" (e.g. the base point G) is not necessarily the same as the order of an elliptic curve.

- h = #E(F_p)/n = [order of the elliptic curve] / [order of the base point]

For secp256k1, h = 1, which means that #E(F_p) == n. This is presumably why the code in the Python ECDSA library didn't include a value for h - it won't make any difference in the calculations.

Some definitions / notes that I liked, found on pages 2 and 6 of x9_62_draft_ecdsa.pdf:

cryptography
The discipline which embodies principles, means and methods for the transformation of data in order to hide its information content, prevent its undetected modification, prevent its unauthorized use, or a combination thereof.

digital signature
The result of a cryptographic transformation of data which, when properly implemented, provides the services of:
1. origin authentication,
2. data integrity, and
3. signer non-repudiation.

Unlike their written counterparts, digital signatures also verify the integrity of information.

Some information on the history of elliptic curve cryptosystems, from page i of x9_62_draft_ecdsa.pdf:

Elliptic curve cryptosystems were first proposed in 1985 independently by Neil Koblitz [23] and Victor Miller [30]. Since then, much research has been done towards improving the efficiency of these systems and evaluating their security. For a summary of this work, consult [28].

In Annex K (References), page 118, I find these references:

[23] = N. KOBLITZ, Elliptic curve cryptosystems, Mathematics of Computation, 48 (1987), 203-209.

[28] = A. MENEZES, Elliptic Curve Public Key Cryptosystems, Kluwer Academic Publishers, 1993.

[30] = V. MILLER, Uses of elliptic curves in cryptography, Advances in Cryptology - CRYPTO '85, Lecture Notes in Computer Science, 218 (1986), Springer-Verlag, 417-426.

Project Log

In my archives, I have code and notes from a previous project, in which I learned how to generate a Bitcoin address. The code and notes are not thorough enough to be worth publishing. However, they are a useful starting point - I know what the route ahead looks like. I mention this because I may derive thoughts / ideas / approaches / sources from this prior work, and, in this project log, it may not always be clear to the reader how or why I chose a particular direction in which to proceed.

My work computer: Aineko, a 2008 Macbook running Mac OS X 10.6.8 Snow Leopard.

aineko:work stjohnpiano$ python --version

Python 2.7.13

Note: I'm going to switch to using the convention of:
- capitalising the word "Bitcoin" when referring to the technology / network / cryptosystem. ("The Bitcoin network is performing X hash operations per second.")
- keeping the word "bitcoin" in lowercase when referring to the unit of account in the Bitcoin cryptosystem. ("This computer costs X bitcoin").
Note: There's an edge case when the unit-of-account "bitcoin" appears at the beginning of a sentence and is therefore capitalised. ("Bitcoin to be sent to seller: X" or "Bitcoin is stored on a public distributed ledger.")

Some notes from an earlier article (Reading and verifying a standard raw bitcoin transaction):

- In the Bitcoin system, the amount of money you have is equivalent to: the sum of the values of the currently-unspent transaction outputs associated with addresses that you control. The existence of the monetary item "bitcoin" derives from the existence of previous transactions (which are stored in the blockchain).

- A Bitcoin address is not just a global ID, like an account number in a bank. A standard address is a value that encodes a hash of a Bitcoin public key. The network nodes, following the Bitcoin ruleset, verify that new transactions that spend bitcoin from an address are signed by a public key that hashes to the value encoded in that address. The nodes reject transactions that do not satisfy this cryptographic condition.
-- Standard transaction inputs include the public key that was used to make the signature. The nodes examine the transaction, extract the publish key, hash it, and confirm that the hash value matches the hash value stored within the originating address (from which the bitcoin is being spent via the transaction). The nodes also confirm that the signature of the transaction was created by this public key.

- Bitcoin addresses are base58-encoded strings containing an address version number, the hash of the Bitcoin public key, and an error-detection checksum to catch typos.
-- If you type out an address, and make a mistake, the checksum will be invalid. Code can be written to analyse the address and catch an invalid checksum before any bitcoin is sent to the address.

- The hash of the key is calculated by applying the SHA256 hash algorithm to the public key and then applying the RIPEMD-160 hash algorithm to the result. So hash(key) == RIPEMD-160(SHA256(key)). The key must be converted into raw bytes before hashing (i.e. not left in hex format).

- Bitcoin ECDSA public keys represent a point on a particular Elliptic Curve (EC) defined in secp256k1. This curve is y^2 = x^3 + 7. In their traditional uncompressed form, public keys contain an identification byte, a 32-byte X coordinate, and a 32-byte Y coordinate.
-- This identification byte is 04 (in hex).

- The Elliptic Curve DSA algorithm generates a 512-bit (64-byte) public key from the private key.

- ECDSA == Elliptic Curve Digital Signature Algorithm

- A Bitcoin ECDSA private key in standard format is simply a 256-bit (32-byte) number, between the values:
-- 0x01
and
-- 0xFFFF FFFF FFFF FFFF FFFF FFFF FFFF FFFE BAAE DCE6 AF48 A03B BFD2 5E8C D036 4140
This range represents nearly the entire range of 2^256-1 values. It is set by the secp256k1 ECDSA encryption standard.
-- I am not certain about this note. I need to look up the relevant documentation and double-check these values.

- To catch typos, private keys can be stored in Wallet Import Format (WIF). This is a Base58Check encoding of the private key into ASCII, which can later be reversed to obtain the 256-bit (32-byte) private key.

Create a project directory ("generating_a_bitcoin_address"). Inside the project directory, create a work directory ("work").

Browse to the earlier article
Reading and verifying a standard raw bitcoin transaction
and download these three assets:

- bjorn_edstrom_ripemd160.py
- ecdsa-0.10.tar.gz
- pypy_sha256.py

Notes on the authorship of these items:

bjorn_edstrom_ripemd160.py is a Python implementation of RIPEMD-160, written by Björn Edström, published 16 December 2007. I downloaded it on 2017-08-04.

ecdsa-0.10.tar.gz is a Python implementation of ECDSA cryptography, written by Peter Pearson, published in 2005. Some comments/updates in the code are dated 2006, 2008, and 2009. Brian Warner added a wrapper around the original code in 2010. I downloaded it while writing the article to which it is attached as an asset.

pypy_sha256.py is a Python implementation of SHA256. I don't know who the author is. I downloaded it on 2017-05-12.

Unpack the zipped tape archive file:

aineko:work stjohnpiano$ tar -zxvf ecdsa-0.10.tar.gz

x ecdsa-0.10/
x ecdsa-0.10/ecdsa/
x ecdsa-0.10/ecdsa/__init__.py
x ecdsa-0.10/ecdsa/_version.py
x ecdsa-0.10/ecdsa/curves.py
x ecdsa-0.10/ecdsa/der.py
x ecdsa-0.10/ecdsa/ecdsa.py
x ecdsa-0.10/ecdsa/ellipticcurve.py
x ecdsa-0.10/ecdsa/keys.py
x ecdsa-0.10/ecdsa/numbertheory.py
x ecdsa-0.10/ecdsa/rfc6979.py
x ecdsa-0.10/ecdsa/six.py
x ecdsa-0.10/ecdsa/test_pyecdsa.py
x ecdsa-0.10/ecdsa/util.py
x ecdsa-0.10/LICENSE
x ecdsa-0.10/MANIFEST.in
x ecdsa-0.10/NEWS
x ecdsa-0.10/PKG-INFO
x ecdsa-0.10/README.md
x ecdsa-0.10/setup.py

Copy the "ecdsa" directory from within the "ecdsa-0.10" directory into the "work" directory. This means that a Python script in the work directory can import the library with

import ecdsa

.

Create a new directory "archive" in the project directory. Move "ecdsa-0.10" and "ecdsa-0.10.tar.gz" into "archive".

Excerpts from:
en.bitcoin.it/wiki/Address

Most Bitcoin addresses are 34 characters. They consist of random digits and uppercase and lowercase letters, with the exception that the uppercase letter "O", uppercase letter "I", lowercase letter "l", and the number "0" are never used to prevent visual ambiguity.

[...] A significant percentage of Bitcoin addresses are only 33 characters, and some addresses may be even shorter. Every Bitcoin address stands for a number. These shorter addresses are valid simply because they stand for numbers that happen to start with zeroes, and when the zeroes are omitted, the encoded address gets shorter.

Excerpts from:
en.bitcoin.it/wiki/Technical_background_of_version_1_Bitcoin_addresses

How to create Bitcoin Address

0 - Having a private ECDSA key

[...]

1 - Take the corresponding public key generated with it [...]

2 - Perform SHA-256 hashing on the public key

[...]

3 - Perform RIPEMD-160 hashing on the result of SHA-256

[...]

4 - Add version byte in front of RIPEMD-160 hash (0x00 for Main Network)

[...]

note that below steps are the Base58Check encoding [...]

5 - Perform SHA-256 hash on the extended RIPEMD-160 result

[...]

6 - Perform SHA-256 hash on the result of the previous SHA-256 hash

[...]

7 - Take the first 4 bytes of the second SHA-256 hash. This is the address checksum

[...]

8 - Add the 4 checksum bytes from stage 7 at the end of extended RIPEMD-160 hash from stage 4. This is the 25-byte binary Bitcoin Address.

[...]

9 - Convert the result from a byte string into a base58 string using Base58Check encoding. This is the most commonly used Bitcoin Address format

Hm.

Excerpts from:
en.bitcoin.it/wiki/Base58Check_encoding

Base58Check encoding

[...]

The original Bitcoin client source code explains the reasoning behind base58 encoding:

base58.h:

// Why base-58 instead of standard base-64 encoding?
// - Don't want 0OIl characters that look the same in some fonts and
// could be used to create visually identical looking account numbers.
// - A string with non-alphanumeric characters is not as easily accepted as an account number.
// - E-mail usually won't line-break if there's no punctuation to break at.
// - Doubleclicking selects the whole number as one word if it's all alphanumeric.

Features of Base58Check

Base58Check has the following features:

- An arbitrarily sized payload.
- A set of 58 alphanumeric symbols consisting of easily distinguished uppercase and lowercase letters (0OIl are not used)
- One byte of version/application information. Bitcoin addresses use 0x00 for this byte [...].
- Four bytes (32 bits) of SHA256-based error checking code. This code can be used to automatically detect and possibly correct typographical errors.
- An extra step for preservation of leading zeroes in the data.

Creating a Base58Check string

1) Take the version byte and payload bytes, and concatenate them together (bytewise).

2) Take the first four bytes of SHA256(SHA256(results of step 1))

3) Concatenate the results of step 1 and the results of step 2 together (bytewise).

4) Treating the results of step 3 - a series of bytes - as a single big-endian bignumber, convert to base-58 using normal mathematical steps (bignumber division) and the base-58 alphabet described below. The result should be normalized to not have any leading base-58 zeroes (character '1').

5) The leading character '1', which has a value of zero in base58, is reserved for representing an entire leading zero byte, as when it is in a leading position, has no value as a base-58 symbol. There can be one or more leading '1's when necessary to represent one or more leading zero bytes. Count the number of leading zero bytes that were the result of step 3 (for old Bitcoin addresses, there will always be at least one for the version/application byte [...]). Each leading zero byte shall be represented by its own character '1' in the final result.

6) Concatenate the 1's from step 5 with the results of step 4. This is the Base58Check result.

[...]

Base58 symbol chart

The Base58 symbol chart used in Bitcoin is specific to the Bitcoin project and is not intended to be the same as any other Base58 implementation used outside the context of Bitcoin (the characters excluded are: 0, O, I, and l).

Value | Character 0 | 1 1 | 2 2 | 3 3 | 4 4 | 5 5 | 6 6 | 7 7 | 8 8 | 9 9 | A 10 | B 11 | C 12 | D 13 | E 14 | F 15 | G 16 | H 17 | J 18 | K 19 | L 20 | M 21 | N 22 | P 23 | Q 24 | R 25 | S 26 | T 27 | U 28 | V 29 | W 30 | X 31 | Y 32 | Z 33 | a 34 | b 35 | c 36 | d 37 | e 38 | f 39 | g 40 | h 41 | i 42 | j 43 | k 44 | m 45 | n 46 | o 47 | p 48 | q 49 | r 50 | s 51 | t 52 | u 53 | v 54 | w 55 | x 56 | y 57 | z

The algorithm for encoding address_byte_string (consisting of 1-byte_version + hash_or_other_data + 4-byte_check_code) is
code_string = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
x = convert_bytes_to_big_integer(hash_result)
output_string = ""
while(x > 0)
   {
	   (x, remainder) = divide(x, 58)
	   output_string.append(code_string[remainder])
   }
repeat(number_of_leading_zero_bytes_in_hash)
   {
   output_string.append(code_string[0]);
   }
output_string.reverse();

Ok. Let's rewrite.

Generating a Bitcoin address:

1) Create an ECDSA private key.

2) Generate the corresponding ECDSA public key.

3) Hash the public key using the SHA256 algorithm.

4) Hash the result of step (3) using the RIPEMD-160 algorithm.

5) Add the version byte in front of the result of step (4). For the main Bitcoin network, the version byte is 0x00. Another way to describe this step is: Bytewise concatenate the version byte and the result of step (4).

6) Hash the result of step (5) using the SHA256 algorithm.

7) Hash the result of step (6) using the SHA256 algorithm.

8) Select the first four bytes of step (7).

9) Bytewise concatenate the result of step (5) and step (8).

10) Treating the result of step (9) as a single big-endian bignumber, convert it to base-58 using bignumber division. This result should not have any leading zeros.

11) Count the number of leading zeros in the result of step (5).

12) Let the result of step (11) be N. Add N '1' characters in front of the result of step (10). Each of these represents a leading zero byte that was not preserved in step (10).

Steps 6-12 comprise the Base58Check algorithm.

Algorithm for step (10):
- Convert the byte sequence to a big integer. How this is done will depend on the programming language. The result must be stored in a big integer data type upon which a division operation can be performed.
- Set a result string R to be an empty string.
- Repeatedly divide the big integer by 58. Using the base-58 conversion table (below), convert the remainder of each division into a base-58 symbol. Append this symbol to the end of R. Stop when the result is 0.
- Reverse the result string R.

Base-58 conversion table (Remainder Value => Base-58 Symbol):

Why is R reversed?

Well, the first time that we divide the big integer X by 58, we are essentially asking the question "how many times does 58 go into X?". The remainder is whatever is left over after we have found the answer to this question.

Example: X = 1. 58 goes zero times into 1, and 1 is left over. In base-58, 1 = 1*(58^0).

Example: X = 2. 58 goes zero times into 2, and 2 is left over. In base-58, 2 = 2*(58^0).

Example: X = 58. 58 goes once into 58, and 0 is left over. In base-58, 58 = 1*(58^1) + 0*(58^0).

Example: X = 59. 58 goes once into 59, and 1 is left over. In base-58, 59 = 1*(58^1) + 1*(58^0).

Example: X = 60. 58 goes once into 60, and 2 is left over. In base-58, 60 = 1*(58^1) + 2*(58^0).

In these examples, the remainder is the answer to the question "how many units of 58^0 were left over after dividing X by 58?".

The second time that we divide the big integer X by 58, we are actually dividing the result of the first division. The question is now "how many times does 58 go into the result of dividing X by 58?", or rather "how many times does 58^2 go into X?". In this second division, the remainder is "how many units of 58^1 were left over after finding out how many times 58^2 went into X?".

Example: X = 3483. 58 goes 60 times into 3365, and 3 is left over. The result of the division, Y, is 60, which is greater than or equal to 58, so a second division can be performed. This second division calculates how many times 58 goes into Y, or, equivalently, how many times 58^2 goes into X.
Division 2: 58 goes once into 60, and 2 is left over.
So, in base-58, 3481 = 1*(58^2) + 2*(58^1) + 3*(58^0).

In the first division, we find the remainder that describes the lowest power of 58 (i.e. 58^0). In the previous example, this remainder was 3. In the second division, we find the remainder of the next highest power of 58 (58^1) that is present in the original big integer X. In the previous example, this remainder was 2.

Technically, there is a third division, or there usually would be in code, in order to terminate the algorithm by confirming that the last result is 0. In the previous example, the last result is 1. Once the third division by 58 is performed, the result is 0, and the remainder is 1.

The point of the divisions is to acquire the sequence of remainders that describe the resulting base-58 number. Notice that we find the remainders in order from lowest to highest, but to then know the final base-58 number, this sequence of remainders must be arranged from highest to lowest.

In the algorithm for step (10), during each division, the remainder (once converted to a base-58 symbol) could instead be prepended to the result string R, without the "reverse R" step at the end. However, prepending a character to a string is usually more computationally expensive than appending to a string, so it is faster to repeatedly append to R and to then perform a final reversal step.

Let's create an ECDSA private key.

I want to confirm the value of this maximum number for a private key:
0xFFFF FFFF FFFF FFFF FFFF FFFF FFFF FFFE BAAE DCE6 AF48 A03B BFD2 5E8C D036 4140

The elliptic curve is named "secp256k1".

The original source for this value was
bitcoin.org/en/developer-guide

That source links the word "secp256k1" to:
www.secg.org/sec2-v2.pdf

According to my notes, I downloaded a copy of sec2-v2.pdf from this link on 2017-05-16 and saved it as
SEC_2_Recommended_Elliptic_Curve_Domain_Parameters_v2.pdf

I've changed its name to sec2_v2.pdf and added it as an asset to this article.

SEC stands for Standards for Efficient Cryptography.

On page 9 of this file, I find:

2.4.1 Recommended Parameters secp256k1

The elliptic curve domain parameters over F_p associated with a Koblitz curve secp256k1 are specified by the sextuple T = (p, a, b, G, n, h) where the finite field F_p is defined by:

p = FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFE FFFFFC2F

= 2^256 - 2^32 - 2^9 - 2^8 - 2^7 - 2^6 - 2^4 - 1

The curve E: y^2 = x^3 + ax + b over F_p is defined by:

a = 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
b = 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000007

The base point G in compressed form is:

G = 02 79BE667E F9DCBBAC 55A06295 CE870B07 029BFCDB 2DCE28D9 59F2815B 16F81798

and in uncompressed form is:

G = 04 79BE667E F9DCBBAC 55A06295 CE870B07 029BFCDB 2DCE28D9 59F2815B 16F81798 483ADA77 26A3C465 5DA4FBFC 0E1108A8 FD17B448 A6855419 9C47D08F FB10D4B8

Finally the order n of G and the cofactor are:

n = FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFE BAAEDCE6 AF48A03B BFD25E8C D0364141
h = 01

2 hex characters == 1 byte. Each 8-hex-character sequence is 4 bytes. As expected, I note that (without the preceding 02) the compressed form of G is 32 bytes long and that (without the preceding 04) the uncompressed form of G is 64 bytes long.

The order "n" of G is 32 bytes long. Its value is
FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFE BAAEDCE6 AF48A03B BFD25E8C D0364141

The value that I wished to confirm is:
FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFE BAAEDCE6 AF48A03B BFD25E8C D0364140

It's nearly the same, except that the last digit in the excerpt value is '1' not '0'. So, the value I currently have (for maximum value of a private key) is 1 less than the value in the specification of the order n of the base point G. Why?

I expected to see something indicating the curve y^2 = x^3 + 7

In the excerpt, the curve form is y^2 = x^3 + ax + b, and a is set to 0 and b is set to 7 (although both a and b are specified in 32-byte hex form), which produces y^2 = x^3 + 7 as expected.

On pages 4-5 of sec2_v2.pdf, I find:

The recommended elliptic curve domain parameters over F_p have been given nicknames to enable them to be easily identified. The nicknames were chosen as follows. Each name begins with "sec" to denote "Standards for Efficient Cryptography", followed by a "p" to denote parameters over F_p, followed by a number denoting the length in bits of the field size "p", followed by a "k" to denote parameters associated with a Koblitz curve or an "r" to denote verifiably random parameters, followed by a sequence number.

2.1 Properties of Elliptic Curve Domain Parameters over F_p

Following SEC 1 [SEC 1], elliptic curve domain parameters over F_p are a sextuple:

T = (p,a,b,G,n,h)

consisting of an integer p specifying the finite field F_p, two elements [a, b element_of F_p] specifying an elliptic curve E(F_p) defined by the equation:

E: y^2 triple_bar x^3 + a.x + b (mod p)

a base point G = (x_G, y_G) on E(F_p), a prime n which is the order of G, and an integer h which is the cofactor [h = #E(F_p)/n].

When elliptic curve domain parameters are specified in this document, each component of this sextuple is represented as an octet string converted using the conventions specified in SEC 1 [SEC 1].

Again following SEC 1 [SEC 1], elliptic curve domain parameters over Fp must have:

ceiling(log_2 p) element_of {192, 224, 256, 384, 521}

This restriction is designed to encourage interoperability while allowing implementers to supply commonly required security levels - recall that elliptic curve domain parameters over F_p with ceiling(log_2 p) = 2t supply approximately t bits of security - meaning that solving the logarithm problem on the associated elliptic curve is believed to take approximately 2t operations.

Here recommended elliptic curve domain parameters are supplied at each of the sizes allowed in SEC 1.

All the recommended elliptic curve domain parameters over F_p use special form primes for their field order p. These special form primes facilitate especially efficient implementations like those described in [Nat99]. Recommended elliptic curve domain parameters over F_p which use random primes for their field order p may be added later if commercial demand for such parameters increases.

The elliptic curve domain parameters over F_p supplied at each security level typically consist of examples of two different types of parameters - one type being parameters associated with a Koblitz curve and the other type being parameters chosen verifiably at random - although only verifiably random parameters are supplied at export strength and at extremely high strength.

Parameters associated with a Koblitz curve admit especially efficient implementation. The name Koblitz curve is best-known when used to describe binary anomalous curves over F_(2^m) which have [a,b element_of {0,1}] [Kob92]. Here it is generalized to refer also to curves over F_p which possess an efficiently computable endomorphism [GLV01]. The recommended parameters associated with a Koblitz curve were chosen by repeatedly selecting parameters admitting an efficiently computable endomorphism until a prime order curve was found.

From the References section at the end of the file:
- [SEC 1] = Standards for Efficient Cryptography Group. SEC 1: Elliptic Curve Cryptography, Mar. 2009. Version 2.0. http://www.secg.org/download/aid-780/sec1-v2.pdf.
- [Nat99] = National Institute of Standards and Technology. Recommended Elliptic Curves for Federal Government Use, Jul. 1999. csrc.nist.gov/encryption.
- [Kob92] = N. Koblitz. CM-curves with good cryptographic properties. In J. Feigenbaum (ed.), Advances in Cryptology - CRYPTO '91, Lecture Notes in Computer Science 576, pp. 279-287. International Association for Cryptologic Research, Springer, 1992.
- [GLV01] = R. P. Gallant, R. J. Lambert and S. A. Vanstone. Faster point multiplication on elliptic curves with efficient endomorphisms. In J. Kilian (ed.), Advances in Cryptology - CRYPTO 2001, Lecture Notes in Computer Science 2139, pp. 190-200. International Association for Cryptologic Research, Springer, 2001.

Hm.

So:
- p specifies the finite field F_p.
- a and b specify the curve E over F_p, or E(F_p).
- G is the base point. I currently think that elliptic curve cryptography involves choosing another point X on the specified curve and multiplying it together with G.
- n is the order of G. Perhaps X must be less than the value of order n if it is to be successfully multiplied with G.

Hm. I can take a look at which values will be accepted for private keys by the ECDSA library I have.

I'll read through some of the code.

The first 54 lines of ecdsa.py are interesting:

	#! /usr/bin/env python

	"""
	Implementation of Elliptic-Curve Digital Signatures.

	Classes and methods for elliptic-curve signatures:
	private keys, public keys, signatures,
	NIST prime-modulus curves with modulus lengths of
	192, 224, 256, 384, and 521 bits.

	Example:

	# (In real-life applications, you would probably want to
	# protect against defects in SystemRandom.)
	from random import SystemRandom
	randrange = SystemRandom().randrange

	# Generate a public/private key pair using the NIST Curve P-192:

	g = generator_192
	n = g.order()
	secret = randrange( 1, n )
	pubkey = Public_key( g, g * secret )
	privkey = Private_key( pubkey, secret )

	# Signing a hash value:

	hash = randrange( 1, n )
	signature = privkey.sign( hash, randrange( 1, n ) )

	# Verifying a signature for a hash value:

	if pubkey.verifies( hash, signature ):
	print_("Demo verification succeeded.")
	else:
	print_("*** Demo verification failed.")

	# Verification fails if the hash value is modified:

	if pubkey.verifies( hash-1, signature ):
	print_("**** Demo verification failed to reject tampered hash.")
	else:
	print_("Demo verification correctly rejected tampered hash.")

	Version of 2009.05.16.

	Revision history:
	2005.12.31 - Initial version.
	2008.11.25 - Substantial revisions introducing new classes.
	2009.05.16 - Warn against using random.randrange in real applications.
	2009.05.17 - Use random.SystemRandom by default.

	Written in 2005 by Peter Pearson and placed in the public domain.
	"""

The variable

secret

(presumably meaning "private key") is chosen from a value between 1 and n.

Google "randrange python".

First result:
docs.python.org/2/library/random.html

Python version drop-down list is set to version 2.7.15.

Excerpts:

Functions for integers:

random.randrange(stop)
random.randrange(start, stop[, step])

Return a randomly selected element from
range(start, stop, step)
. This is equivalent to
choice(range(start, stop, step))
, but doesn't actually build a range object.

New in version 1.5.2.

random.randint(a, b)

Return a random integer N such that
a <= N <= b
.

Functions for sequences:

random.choice(seq)

Return a random element from the non-empty sequence seq. If seq is empty, raises IndexError.

In Python, range(0,5) returns [0,1,2,3,4]. The last value is excluded.

So, here, in the random module, in

choice(range(start, stop))

choice

will choose from all values included in the range [start, stop-1].

The function

randrange

is equivalent to

choice(range(start, stop))

. This means that

secret = randrange( 1, n )

will return a value included in the range [1,n-1].

This in turn indicates the author of the ECDSA library thinks that subtracting 1 from the order n of the base point G is indeed correct (and also excluding the value 0), although I still don't know why.

In these lines,

	n = g.order()
	secret = randrange( 1, n )
	pubkey = Public_key( g, g * secret )
	privkey = Private_key( pubkey, secret )

I'm surprised that the public key appears to be a necessary argument for constructing the private key from the secret. Possibly, however, the private key object in this system stores a record of the corresponding public key object. Perhaps the pubkey is an optional argument.

Reading further in ecdsa.py, I find that:
- A comment in the Public_key class (in the method

verifies

) cites "X9.62 J.3.1." as its source.
- The __init__ method for the Private_key class simply stores the secret and the public key in attributes. The secret argument must be a large integer (not a byte string).
-- The pubkey is not an optional argument.

I also find this function:

	def string_to_int( s ):
	"""Convert a string of bytes into an integer, as per X9.62."""
	result = 0
	for c in s:
	if not isinstance(c, int): c = ord( c )
	result = 256 * result + c
	return result

I can use this function to turn a byte string into an integer, so that it can be used as an input to the Private_key and Public_key class constructors.

I like the per-byte processing approach.

The

isinstance

check puzzles me. No byte in a byte string s should be an instance of type 'int'.

A little testing:

aineko:work stjohnpiano$ python

>>> s = [chr(x) for x in range(256)]
>>> s
>>> ['\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07', '\x08', '\t', '\n', '\x0b', '\x0c', '\r', '\x0e', '\x0f', '\x10', '\x11', '\x12', '\x13', '\x14', '\x15', '\x16', '\x17', '\x18', '\x19', '\x1a', '\x1b', '\x1c', '\x1d', '\x1e', '\x1f', ' ', '!', '"', '#', '$', '%', '&', "'", '(', ')', '*', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?', '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\', ']', '^', '_', '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~', '\x7f', '\x80', '\x81', '\x82', '\x83', '\x84', '\x85', '\x86', '\x87', '\x88', '\x89', '\x8a', '\x8b', '\x8c', '\x8d', '\x8e', '\x8f', '\x90', '\x91', '\x92', '\x93', '\x94', '\x95', '\x96', '\x97', '\x98', '\x99', '\x9a', '\x9b', '\x9c', '\x9d', '\x9e', '\x9f', '\xa0', '\xa1', '\xa2', '\xa3', '\xa4', '\xa5', '\xa6', '\xa7', '\xa8', '\xa9', '\xaa', '\xab', '\xac', '\xad', '\xae', '\xaf', '\xb0', '\xb1', '\xb2', '\xb3', '\xb4', '\xb5', '\xb6', '\xb7', '\xb8', '\xb9', '\xba', '\xbb', '\xbc', '\xbd', '\xbe', '\xbf', '\xc0', '\xc1', '\xc2', '\xc3', '\xc4', '\xc5', '\xc6', '\xc7', '\xc8', '\xc9', '\xca', '\xcb', '\xcc', '\xcd', '\xce', '\xcf', '\xd0', '\xd1', '\xd2', '\xd3', '\xd4', '\xd5', '\xd6', '\xd7', '\xd8', '\xd9', '\xda', '\xdb', '\xdc', '\xdd', '\xde', '\xdf', '\xe0', '\xe1', '\xe2', '\xe3', '\xe4', '\xe5', '\xe6', '\xe7', '\xe8', '\xe9', '\xea', '\xeb', '\xec', '\xed', '\xee', '\xef', '\xf0', '\xf1', '\xf2', '\xf3', '\xf4', '\xf5', '\xf6', '\xf7', '\xf8', '\xf9', '\xfa', '\xfb', '\xfc', '\xfd', '\xfe', '\xff']

>>> for c in s:
... if isinstance(c, int): print c,
...
...
>>>

The ASCII visible characters are printed directly. The whitespace characters are printed as backslash-escaped characters (as is the backslash character itself). All other bytes are displayed as hex values.

So, I can remove the

isinstance

check, and add a check confirming that the input is a string, producing:

def string_to_int(s):

	"""Convert a string of bytes into an integer, as per X9.62."""

	if not isinstance(s, str):

		raise Exception("\nERROR: input s must be a string.\n")

	result = 0

	for character in s:

		byte_value = ord(character)

		# each new byte in the string means that the previous integer result should be multiplied by 2**8 = 256.

		result = 256 * result + byte_value

	return result

I also find the constants for curve secp256k1:

	# Certicom secp256-k1
	_a = 0x0000000000000000000000000000000000000000000000000000000000000000
	_b = 0x0000000000000000000000000000000000000000000000000000000000000007
	_p = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f
	_Gx = 0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
	_Gy = 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8
	_r = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141

	curve_secp256k1 = ellipticcurve.CurveFp( _p, _a, _b)
	generator_secp256k1 = ellipticcurve.Point( curve_secp256k1, _Gx, _Gy, _r)

Let's compare these to the values in the relevant earlier excerpt from sec2_v2.pdf.

Map variable names:
_a = a
_b = b
_p = p
_Gx = X-value of base point G
_Gy = Y-value of base point G
_r = n

No mention of the cofactor h for secp256k1 in the ECDSA library.

Compare values:
_a == a == 0
_b == b == 7
_p == p. First six 4-byte chunks are all FFFFFFFF. Last two 4-byte chunks are: FFFFFFFE FFFFFC2F == fffffffefffffc2f

uncompressed G = 04 79BE667E F9DCBBAC 55A06295 CE870B07 029BFCDB 2DCE28D9 59F2815B 16F81798 483ADA77 26A3C465 5DA4FBFC 0E1108A8 FD17B448 A6855419 9C47D08F FB10D4B8
Assume X-value is first eight 4-byte chunks and Y-value is last eight 4-byte chunks.
X-value of base point G is: 79BE667E F9DCBBAC 55A06295 CE870B07 029BFCDB 2DCE28D9 59F2815B 16F81798
Y-value of base point G is: 483ADA77 26A3C465 5DA4FBFC 0E1108A8 FD17B448 A6855419 9C47D08F FB10D4B8

In python:

>>> x1 = "79BE667E F9DCBBAC 55A06295 CE870B07 029BFCDB 2DCE28D9 59F2815B 16F81798"
>>> x2 = "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"
>>> x2 == x1.lower().replace(' ','')
>>> True

>>> y1 = "483ADA77 26A3C465 5DA4FBFC 0E1108A8 FD17B448 A6855419 9C47D08F FB10D4B8"
>>> y2 = "483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8"
>>> y2 == y1.lower().replace(' ','')
>>> True

Cool. Gx and Gy values are the same.

Finally, the order n (or '_r').

>>> _r = "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"
>>> _r == n.lower().replace(' ','')
>>> True

Good. The library uses values that match those found in sec2_v2.pdf.

In the ecdsa library, in keys.py, I find the SigningKey.from_secret_exponent() method, which by default is used by the SigningKey class as a constructor.

	@classmethod
	def from_secret_exponent(klass, secexp, curve=NIST192p, hashfunc=sha1):
	self = klass(_error__please_use_generate=True)
	self.curve = curve
	self.default_hashfunc = hashfunc
	self.baselen = curve.baselen
	n = curve.order
	assert 1 <= secexp < n
	pubkey_point = curve.generator*secexp
	pubkey = ecdsa.Public_key(curve.generator, pubkey_point)
	pubkey.order = n
	self.verifying_key = VerifyingKey.from_public_point(pubkey_point, curve,
	hashfunc)
	self.privkey = ecdsa.Private_key(pubkey, secexp)
	self.privkey.order = n
	return self

In context, secexp == "secret".

This line

assert 1 <= secexp < n

is a further confirmation of the minimum/maximum of the value range of an ECDSA private key for the curve secp256k1.

I'll have a look at X9.62. It might explain why these constraints exist for the value range.

In ellipticcurve.py, I find this:

# Notes from X9.62-1998 (draft):

This is presumably the version of X9-62 used for writing this library.

Google "X9.62-1998 (draft)".

First result:
citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.202.2977&rep=rep1&type=pdf

According to my notes, I downloaded a copy of this PDF document from this link on 2017-05-16 and saved it as
draft_x9_ansi_ecdsa_for_financial_industry.pdf

I'll change its name to x9_62_draft_ecdsa.pdf and add it as an asset to this article.

The cover page:

Accredited Standards Committee X9
Title: X9-Financial Services
Accredited by the American National Standards Institute
September 20, 1998

Working Draft
AMERICAN NATIONAL STANDARD
X9.62-1998
Public Key Cryptography For The Financial Services Industry: The Elliptic Curve Digital Signature Algorithm (ECDSA)©

Notice -- This document is a draft document. It has not yet been processed through the consensus procedures of X9 and ANSI.
Many changes which may greatly affect its contents can occur before this document is completed.
The working group may not be held responsible for the contents of this document.
Implementation or design based on this draft is at the risk of the user. No advertisement or citation implying compliance with a "Standard" should appear as it is erroneous and misleading to so state.
Copies of the draft proposed American National Standard will be available from the X9 Secretariat when the document is finally announced for two months public comment. Notice of this announcement will be in the trade press.

Secretariat: American Bankers Association
Standards Department
1120 Connecticut Ave., N.W.
Washington, DC 20036

© 1998 American Bankers Association
All rights reserved

ANSI = American National Standards Institute

On page i, I find:

This Standard, X9.62-1998, Public Key Cryptography For The Financial Services Industry: The Elliptic Curve Digital Signature Algorithm (ECDSA), defines a technique for generating and validating digital signatures.
This Standard describes a method for digital signatures using the elliptic curve analog of the Digital Signature Algorithm (DSA) (ANSI X9.30 Part 1 [3]).
Elliptic curve systems are public-key (asymmetric) cryptographic algorithms that are typically used:
1. to create digital signatures (in conjunction with a hash algorithm), and
2. to establish secret keys securely for use in symmetric-key cryptosystems.
When implemented with proper controls, the techniques of this Standard provide:
1. data integrity,
2. data origin authentication, and
3. non-repudiation of the message origin and the message contents.

In Annex K (References), page 118, I find that [3] refers to:
ANSI X9.30-1995, Part 1: Public key cryptography using irreversible algorithms for the financial services industry: The Digital Signature Algorithm (Revised).

On this page, I also find:

Elliptic curve cryptosystems were first proposed in 1985 independently by Neil Koblitz [23] and Victor Miller [30]. Since then, much research has been done towards improving the efficiency of these systems and evaluating their security. For a summary of this work, consult [28]. A description of a hardware implementation of an elliptic curve cryptosystem can be found in [9].

Three references on the theory of finite fields are the books of McEliece [27], Lidl and Niederreiter [26] and Jungnickel [21]. Lidl and Niederreiter's book [26] contains introductory material on polynomial and normal bases. The article [8] discusses methods which efficiently perform arithmetic operations in finite fields of characteristic 2. A hardware implementation of arithmetic in such fields which exploits the properties of optimal normal bases is described in [10].

The NIST Digital Signature Algorithm (DSA) is described in [3] and [32]. The Secure Hash Algorithm (SHA-1) is described in [4] and [31]. Abstract Syntax Notation One (ASN.1) is described in [15]; see also [16], [17], [18], [19] and [20]. Basic Encoding Rules (BER) and Distinguished Encoding Rules (DER) are described in [19].

In the Definitions and Abbreviations section, on page 2, I find:

cryptography
The discipline which embodies principles, means and methods for the transformation of data in order to hide its information content, prevent its undetected modification, prevent its unauthorized use, or a combination thereof.

[...]

digital signature
The result of a cryptographic transformation of data which, when properly implemented, provides the services of:
1. origin authentication,
2. data integrity, and
3. signer non-repudiation.

I like these definitions.

On page 2, I also find:

elliptic curve
An elliptic curve over F_q is a set of points which satisfy a certain equation specified by 2 parameters a and b, which are elements of a field F_q. (See Section 4.2.)

elliptic curve key pair (Q, d)
Given particular elliptic curve domain parameters, an elliptic curve key pair consists of an elliptic curve public key (Q) and the corresponding elliptic curve private key (d).

elliptic curve private key (d)
Given particular elliptic curve domain parameters, an elliptic curve private key, d, is a statistically unique and unpredictable integer in the interval [1, n-1], where n is the prime order of the base point G.

elliptic curve public key (Q)
Given particular elliptic curve domain parameters, and an elliptic curve private key d, the corresponding elliptic curve public key, Q, is the elliptic curve point Q = dG, where G is the base point. Note that Q will never equal point_at_infinity, since 1 <= d <= n-1.

elliptic curve domain parameters
Elliptic curve domain parameters are comprised of a field size q, indication of basis used (in the case q = 2^m), an optional SEED, two elements a, b in F_q which define an elliptic curve E over F_q, a point G = (x_G,y_G) of prime order in E(F_q), the order n of G, and the cofactor h. See Sections 5.1.1.1 and 5.1.2.1 for a complete specification of elliptic curve domain parameters.

elliptic curve point
If E is an elliptic curve defined over a field F_q, then an elliptic curve point P is either: a pair of field elements (x_p, y_p) (where x_p, y_p element_of F_q) such that the values x = x_p and y = y_p satisfy the equation defining E, or a special point called the point_at_infinity.

Hm.

n = the prime order of the base point G
d = the private key, in the interval [1,n-1]
Q = the public key, found by multiplying G by d.

Limiting d to the interval [1,n-1] means that Q will never equal the point_at_infinity.

Presumably, in the elliptic curve cryptosystem mathematics, Q != point_at_infinity is a necessary condition.

On page 3, I find:

order of a curve
The order of an elliptic curve E defined over the field F_q is the number of points on E, including the point_at_infinity. This is denoted by #E(F_q).

order of a point
The order of a point P is the smallest positive integer n such that nP = the point_at_infinity.

[...]

prime finite field
A finite field containing p elements, where p is an odd prime number.

So:
- F_p = a field containing p elements. If p is a fixed integer, then the field is "finite". If p is prime, the field F_p is a "prime finite field".
- An elliptic curve over a finite field F_p is denoted by E(F_p).
- the "order of an elliptic curve", denoted by #E(F_p), is the number of points on the curve. This includes the point_at_infinity.
- the "order of a point" (e.g. the base point G) is not the same as the order of an elliptic curve.

Earlier, in sec2_v2.pdf I found that:
- n = a prime that is the order of the base point G
- h = the cofactor found by calculating #E(F_p)/n

So:
- n = prime order of base point G
- #E(F_p) = order of the elliptic curve (in this case, secp256k1)
- h = #E(F_p)/n = [order of the elliptic curve] / [order of the base point]

For secp256k1, h = 1, which means that #E(F_p) == n. This is presumably why the code in the Python ECDSA library didn't include a value for h - it won't make any difference in the calculations.

I don't know how the order n of base point G is calculated from nG = the point_at_infinity. I suspect that the process is not as simple as "divide the point_at_infinity by n".

I also don't why n and #E(F_p) would necessarily be related by a cofactor that is a whole integer. Perhaps the elliptic curves that are in use have been found by searching the curve possibility space until suitable curves (with, among other properties, whole integer values of h) were found.

This sentence found earlier:
"The recommended parameters associated with a Koblitz curve were chosen by repeatedly selecting parameters admitting an efficiently computable endomorphism until a prime order curve was found."
indicates a search for usable curves with particular properties.

On page 5, I find:

h
h = #E(Fq)/n, where n is the order of the base point G. h is called the cofactor.

This is confirmation of the formula for the cofactor h.

On page 6, I find:

Unlike their written counterparts, digital signatures also verify the integrity of information.

[...]

3.2 The Use of the ECDSA Algorithm

The ECDSA is used by a signatory to generate a digital signature on data and by a verifier to verify the authenticity of the signature. Each signatory has a public and private key. The private key is used in the signature generation process, and the public key is used in the signature verification process. For both signature generation and verification, the message, M, is compressed by means of the Secure Hash Algorithm (SHA-1) specified in ANSI X9.30 Part 2 [4], prior to the signature generation and verification process.

An adversary, who does not know the private key of the signatory, cannot feasibly generate the correct signature of the signatory. In other words, signatures cannot be forged. However, by using the signatory's public key, anyone can verify a validly signed message.

Hm. I note that SHA1 is used for signature generation and verification. I thought the Bitcoin cryptosystem only used SHA256 and RIPEMD-160. Is SHA1 involved somewhere?

I'll take a look at check_signature2.py, an asset stored with the article Reading and verifying a standard raw bitcoin transaction.

Excerpt from check_signature2.py:

	# convert sig from DER encoding to hex
	sig_hex_ns = derSigToHexSig(der_sig_hex_ns)

	# convert sig, public key, and hash to raw byte sequences
	hash_raw_byte_string = unhexlify(signable_tx_hash_hex_ns)
	sig_raw_byte_string = unhexlify(sig_hex_ns)
	public_key_raw_byte_string = unhexlify(public_key_hex_ns)

	# create a key object from the raw-byte-sequence public key.
	vk = ecdsa.VerifyingKey.from_string(public_key_raw_byte_string, curve=ecdsa.SECP256k1)

	# verify the signature
	verification_result = vk.verify_digest(sig_raw_byte_string, hash_raw_byte_string)

The signature "sig" is stored in DER encoding within a Bitcoin transaction.

I'll look at VerifyingKey.verify_digest(), which is in keys.py in the ECDSA library.

This uses

if self.pubkey.verifies(number, sig):

for the verification check.

I'll look at Public_key.verifies(), which is in ecdsa.py.

This method "[verifies] that signature is a valid signature of hash.", but it doesn't appear to recalculate the hash, so this doesn't tell me whether SHA1 or SHA256 was used to produce the hash in the first place.

Hm. Wait, the hash is recalculated separately. When verifying the digital signature of a message, you first check that the message hashes to a digest value, then you check that the signature is a valid signature of the digest value.

So, in check_signature2.py, how did I calculate signable_tx_hash_hex_ns?

Ah. I got the transaction-in-signable-form, and hashed it twice with SHA256.

Ok. Looks like SHA1 is not involved with ECDSA signatures in Bitcoin.

In x9_62_draft_ecdsa.pdf, in section 5.1.1.2 (Elliptic curve domain parameter validation over F_p), on page 15, I find:

NOTES:
1. The cofactor h is not used in ECDSA, but is included here for compatibility with ANSI X9.63 [6] where it may be needed.

In Annex K, I find that reference [6] is: ANSI X9.63-199x: Elliptic curve key agreement and transport protocols, draft.

This explains why the cofactor h didn't appear in the ECDSA library code.

Well, I now know a bit more about ECDSA, enough for me to be satisfied that:
- A Bitcoin private key must be in the closed interval [1, n-1] where n is the order of the base point G. For the curve secp256k1, n = FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFE BAAEDCE6 AF48A03B BFD25E8C D0364141, and therefore n-1 = FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFE BAAEDCE6 AF48A03B BFD25E8C D0364140.

I'll use the byte string "hello_world" as a private key.

>>> for c in "hello_world": print ord(c), hex(ord(c))
>>>
... 104 0x68
101 0x65
108 0x6c
108 0x6c
111 0x6f
95 0x5f
119 0x77
111 0x6f
114 0x72
108 0x6c
100 0x64

>>> "".join([hex(ord(c)) for c in 'hello_world'])
>>> '0x680x650x6c0x6c0x6f0x5f0x770x6f0x720x6c0x64'

>>> "".join([hex(ord(c))[2:] for c in 'hello_world'])
>>> '68656c6c6f5f776f726c64'

Note: hex(ord(c)) does not preserve leading zeros. In this case, none of the hex values of the ASCII characters have leading zeros. This would be a problem if, for example, the string had included \t or \n.

So, in hex, "hello_world" is: 68656c6c6f5f776f726c64

This is within the input domain for a Bitcoin private key.

I'll write some Python code to convert this to a public key, making use of the ECDSA library.

[some reading of the ECDSA library, development, and testing occurs here]

__init__.py specifies the items that are imported via the command

import ecdsa

. Among them is the SigningKey class, but not Public_key or Private_key (which are both used by SigningKey). VerifyingKey is also imported, and is also used by SigningKey.

I decided to use SigningKey and VerifyingKey instead of Private_key and Public_key, as that appears to be the choice that the library encourages. The default hashfunc is SHA1, but I'm not generating or verifying any signatures at the moment, so this isn't a problem.

A SigningKey instance generates a corresponding VerifyingKey instance and stores it as an attribute.

The SigningKey.to_string() method returns a byte string version of the secret_multiplier (i.e. the private key, originally supplied to the constructor as an integer).

The VerifyingKey.to_string() method returns: x_str + y_str

calculate_public_key.py

#!/opt/local/bin/python

import ecdsa

from binascii import hexlify, unhexlify

def main():

	private_key_hex = '68656c6c6f5f776f726c64'

	print ""

	private_key_byte_string = unhexlify(private_key_hex)

	private_key_int = string_to_int(private_key_byte_string)

	print "private_key_hex: %s" % private_key_hex

	print "private_key_int: %d" % private_key_int

	signing_key = ecdsa.SigningKey.from_secret_exponent(private_key_int, curve=ecdsa.SECP256k1)

	# note: if the result of to_string() includes any non-printable-ASCII bytes, they won't display well.

	print "signing_key.to_string(): %s" % signing_key.to_string()

	verifying_key = signing_key.verifying_key

	verifying_key_byte_string = verifying_key.to_string()

	verifying_key_hex = hexlify(verifying_key_byte_string)

	print "verifying_key_hex: %s" % verifying_key_hex

	print "len(verifying_key_hex)/2 (i.e. number of bytes): %d" % (len(verifying_key_hex)/2)

	# verifying_key.to_string() returns: x_str + y_str

	a = len(verifying_key_hex)/2

	X = verifying_key_hex[:a]

	Y = verifying_key_hex[a:]

	print "X_value of verifying key (%d bytes): %s" % (a/2, X)

	print "Y_value of verifying key (%d bytes): %s" % (a/2, Y)

	# add identification byte to verifying key ("04" for "uncompressed") to get a usable public key

	public_key_hex = "04" + verifying_key_hex

	print "ECDSA public key with 04 identification byte: %s" % public_key_hex

	print ""

def string_to_int(s):

	"""Convert a string of bytes into an integer, as per X9.62."""

	if not isinstance(s, str):

		raise Exception("\nERROR: input s must be a string.\n")

	result = 0

	for character in s:

		byte_value = ord(character)

		# each new byte in the string means that the previous integer result should be multiplied by 2**8 = 256.

		result = 256 * result + byte_value

	return result

if __name__ == '__main__': main()

aineko:work stjohnpiano$ chmod 700 get_public_key.py

aineko:work stjohnpiano$ ./calculate_public_key.py

private_key_hex: 68656c6c6f5f776f726c64
private_key_int: 126207244316620074054216804
signing_key.to_string(): hello_world
verifying_key_hex: 3cd69b03d4bbbdc07450a36de99e792aaaf00298076d0daa761450156bb9c1b75a72839ce8c498f55fbb69312a661d3572c250e26a0189ae068ef50abc68d3e7
len(verifying_key_hex)/2 (i.e. number of bytes): 64
X_value of verifying key (32 bytes): 3cd69b03d4bbbdc07450a36de99e792aaaf00298076d0daa761450156bb9c1b7
Y_value of verifying key (32 bytes): 5a72839ce8c498f55fbb69312a661d3572c250e26a0189ae068ef50abc68d3e7
ECDSA public key with 04 identification byte: 043cd69b03d4bbbdc07450a36de99e792aaaf00298076d0daa761450156bb9c1b75a72839ce8c498f55fbb69312a661d3572c250e26a0189ae068ef50abc68d3e7

From the (hex value of) the Bitcoin private key "hello_world", I have calculated that the corresponding Bitcoin public key is:
043cd69b03d4bbbdc07450a36de99e792aaaf00298076d0daa761450156bb9c1b75a72839ce8c498f55fbb69312a661d3572c250e26a0189ae068ef50abc68d3e7

Next:

3) Hash the public key using the SHA256 algorithm.
and
4) Hash the result of step (3) using the RIPEMD-160 algorithm.

aineko:work stjohnpiano$ python

Python 2.7.13 (default, Dec 18 2016, 05:35:59)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> public_key_hex = "043cd69b03d4bbbdc07450a36de99e792aaaf00298076d0daa761450156bb9c1b75a72839ce8c498f55fbb69312a661d3572c250e26a0189ae068ef50abc68d3e7"

>>> from binascii import hexlify, unhexlify
>>> public_key_byte_string = unhexlify(public_key_hex)
>>> public_key_byte_string
>>> '\x04<\xd6\x9b\x03\xd4\xbb\xbd\xc0tP\xa3m\xe9\x9ey*\xaa\xf0\x02\x98\x07m\r\xaav\x14P\x15k\xb9\xc1\xb7Zr\x83\x9c\xe8\xc4\x98\xf5_\xbbi1*f\x1d5r\xc2P\xe2j\x01\x89\xae\x06\x8e\xf5\n\xbch\xd3\xe7'

>>> from pypy_sha256 import sha256
>>> digest = sha256(public_key_byte_string).digest()
>>> digest
>>> '\xc8\x92e|\x9f\xaf)\xb2\x13\xfdX\xf7\xbd\xc8]\x88\xd7>\x0b\xba\xe5\xa5W\xea\xfa$\xed\x9aA\xf6\x93,'

>>> from bjorn_edstrom_ripemd160 import RIPEMD160
>>> digest2 = RIPEMD160(digest).digest()
>>> digest2
>>> ']*\xecTl\xe9\xab\xafQ\xb5\xef!\x02\xd3z\xeatz\x0f\x90'

>>> result = hexlify(digest2)
>>> result
>>> '5d2aec546ce9abaf51b5ef2102d37aea747a0f90'

>>> len(result)
>>> 40

The result is:
5d2aec546ce9abaf51b5ef2102d37aea747a0f90

Next:

5) Add the version byte in front of the result of step (4). For the main Bitcoin network, the version byte is 0x00.

00 + 5d2aec546ce9abaf51b5ef2102d37aea747a0f90 is:
005d2aec546ce9abaf51b5ef2102d37aea747a0f90

Next:

6) Hash the result of step (5) using the SHA256 algorithm.

7) Hash the result of step (6) using the SHA256 algorithm.

aineko:work stjohnpiano$ python

Python 2.7.13 (default, Dec 18 2016, 05:35:59)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> from pypy_sha256 import sha256
>>> from binascii import hexlify, unhexlify
>>> input_hex = '005d2aec546ce9abaf51b5ef2102d37aea747a0f90'
>>> input_byte_string = unhexlify(input_hex)
>>> digest = sha256(input_byte_string).digest()
>>> digest2 = sha256(digest).digest()
>>> output_hex = hexlify(digest2)
>>> output_hex
>>> '764140ee4681452e81da36e6c81c8266e94e1667e0ffd276ebf84db456e3e5bd'

Result of step (7) is:
764140ee4681452e81da36e6c81c8266e94e1667e0ffd276ebf84db456e3e5bd

Next:
8) Select the first four bytes of step (7).

Result of step(8) is:
764140ee

Next:
9) Bytewise concatenate the result of step (5) and step (8).

005d2aec546ce9abaf51b5ef2102d37aea747a0f90 + 764140ee is:
005d2aec546ce9abaf51b5ef2102d37aea747a0f90764140ee

Next:
10) Treating the result of step (9) as a single big-endian bignumber, convert it to base-58 using bignumber division. This result should not have any leading zeros.

I need to convert the data from big-endian hex to decimal. In Python, this can be accomplished using an

int()

conversion with base=16.

>>> input_hex = '005d2aec546ce9abaf51b5ef2102d37aea747a0f90764140ee'
>>> int(input_hex, 16)
>>> 2284464587074056131856115329755146260938602682621743939822L

I'll remove the 'L' at the end of the result (it's used in Python to indicate a long integer type).

This is the data, converted to decimal (base-10):
2284464587074056131856115329755146260938602682621743939822

I now need to convert this integer from decimal (base-10) to base-58.

convert_from_base_10_to_base_58.py

#!/opt/local/bin/python

def main():

	input = 2284464587074056131856115329755146260938602682621743939822

	print "input: %d" % input

	output = convert_from_base_10_to_base_58(input)

	print "output: %s" % output

def convert_from_base_10_to_base_58(input):

	# - accepts int or long

	# - returns base58-encoded string

	# the string base58_symbols can accessed as a 0-indexed list of characters.

	base58_symbols = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"

	output = ''

	while input > 0:

		input, remainder = divmod(input, 58)

		# use remainder as index for accessing the corresponding base58 symbol.

		output += base58_symbols[remainder]

	output = ''.join(reversed(output))

	return output

if __name__ == '__main__': main()

aineko:work stjohnpiano$ chmod 700 convert_from_base_10_to_base_58.py

aineko:work stjohnpiano$ ./convert_from_base_10_to_base_58.py

input: 2284464587074056131856115329755146260938602682621743939822
output: 9VdGCFG8QH3CmYXjMXd3UQCK2HdC3UodP

The result of step (10) is:
9VdGCFG8QH3CmYXjMXd3UQCK2HdC3UodP

This result does not have any leading zeros ("1"s in Bitcoin's base-58).

Let's test the base-58 conversion with some examples.

Note: Once the remainders digit sequence is found, each digit must be converted into Bitcoin's particular base-58 symbol list.

Symbol list:
123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz

The symbol space is zero-indexed. Each digit found in the examples is used as the index to look up the corresponding symbol in the symbol list.

Of particular note is the fact that the Bitcoin symbol list uses "1" where other base formats usually use the "0" symbol.

Example: X = 1. In base-58, 1 = 1*(58^0) = 1 => 2

Example: X = 2. In base-58, 2 = 2*(58^0) = 2 => 3

Example: X = 58. In base-58, 58 = 1*(58^1) + 0*(58^0) = 1,0 => 21

Example: X = 59. In base-58, 59 = 1*(58^1) + 1*(58^0) = 1,1 => 22

Example: X = 60. In base-58, 60 = 1*(58^1) + 2*(58^0) = 1,2 => 23

Example: X = 3483. In base-58, 3481 = 1*(58^2) + 2*(58^1) + 3*(58^0) = 1,2,3 => 234

Example: X = 57. In base-58, 57 = 57*(58^0) = 57 => z

Example: X = 115. In base-58, 115 = 1*(58^1) + 57*(58^0) = 1,57 => 2z

Change the value of

input

appropriately and re-run the script.

aineko:work stjohnpiano$ ./convert_from_base_10_to_base_58.py

input: 1
output: 2

aineko:work stjohnpiano$ ./convert_from_base_10_to_base_58.py

input: 2
output: 3

aineko:work stjohnpiano$ ./convert_from_base_10_to_base_58.py

input: 58
output: 21

aineko:work stjohnpiano$ ./convert_from_base_10_to_base_58.py

input: 59
output: 22

aineko:work stjohnpiano$ ./convert_from_base_10_to_base_58.py

input: 60
output: 23

aineko:work stjohnpiano$ ./convert_from_base_10_to_base_58.py

input: 3483
output: 234

aineko:work stjohnpiano$ ./convert_from_base_10_to_base_58.py

input: 57
output: z

aineko:work stjohnpiano$ ./convert_from_base_10_to_base_58.py

input: 115
output: 2z

Ok.

Next:
11) Count the number of leading zeros in the result of step (5).

The result of step (5) is:
005d2aec546ce9abaf51b5ef2102d37aea747a0f90

I see one "00" hex-encoded byte at the beginning, i.e. there is 1 leading zero byte.

Next:
12) Let the result of step (11) be N. Add N '1' characters in front of the result of step (10). Each of these represents a leading zero byte that was not preserved in step (10).

N = 1

Result of step (10) is:
9VdGCFG8QH3CmYXjMXd3UQCK2HdC3UodP

1*("1") + 9VdGCFG8QH3CmYXjMXd3UQCK2HdC3UodP =
19VdGCFG8QH3CmYXjMXd3UQCK2HdC3UodP

Result of step (12):
19VdGCFG8QH3CmYXjMXd3UQCK2HdC3UodP

>>> len('19VdGCFG8QH3CmYXjMXd3UQCK2HdC3UodP')
>>> 34

It's 34 characters long, which is fine.

Ok. I've generated a Bitcoin address.

Private key: hello_world
Private key in hex: 68656c6c6f5f776f726c64
Public key in hex:
043cd69b03d4bbbdc07450a36de99e792aaaf00298076d0daa761450156bb9c1b75a72839ce8c498f55fbb69312a661d3572c250e26a0189ae068ef50abc68d3e7
Bitcoin address: 19VdGCFG8QH3CmYXjMXd3UQCK2HdC3UodP

Now, to test the validity of this address, I'll send some bitcoin to it.

I will also import the private key into a wallet and test that I can send the bitcoin from this address to another address.
- Note: I should find out how to generate the WIF (Wallet Import Format) version of the private key in order to import it.

Log in to LocalBitcoins account.

The minimum amount that can currently be sent is 0.0001. The transaction fee is 0.00005.

Note: This transaction fee is the fee that LocalBitcoins charges to its users for outgoing transfers (i.e. transfers to Bitcoin addresses, rather than to other LocalBitcoins accounts). LocalBitcoins usually bundles up multiple customer transfers into single Bitcoin transactions, so the cost per transfer via LocalBitcoins is not necessarily the same as the cost per transaction on the Bitcoin network.

I'll send 0.001 bitcoin (this is about $7.50 at the time of writing).

LocalBitcoins reports "Success. Bitcoins sent successfully to address 19VdGCFG8QH3CmYXjMXd3UQCK2HdC3UodP.".

LocalBitcoins notes that:
"Bitcoin transactions normally take about 30 to 60 minutes to send, on occasion it can take a few hours if the Bitcoin network is slow."

In the Transactions section of my LocalBitcoins wallet, the txid of the transaction containing my transfer is:
e611dfee1e1cb3e0ec1097f19a0012e801fdd0873c7342674f37234f999f77f2

On blockchain.info, using the search utility, I can see:
a) the transaction (as yet unconfirmed):
blockchain.info/tx/e611dfee1e1cb3e0ec1097f19a0012e801fdd0873c7342674f37234f999f77f2
b) my new address with its balance (the transaction is labeled 'unconfirmed').
blockchain.info/address/19VdGCFG8QH3CmYXjMXd3UQCK2HdC3UodP

Now, set an alarm to go off in an hour and do other stuff in the meantime.

1 hour-ish later: 11 confirmations.

Hm. That's interesting. A block should be found every 10 minutes, on average. I would have expected at most 7 confirmations. Evidently there can be a rush of blocks.

After 6 confirmations, the volatile end of the blockchain has passed beyond the block containing my transfer, and I can be fairly sure that this block will not be deleted from the chain.

Next: Generate the WIF form of the private key.

Excerpt from:
Reading and verifying a standard raw bitcoin transaction

Original source:
bitcoin.org/en/developer-guide

Wallet Import Format (WIF)

In order to make copying of private keys less prone to error, Wallet Import Format may be utilized. WIF uses base58Check encoding on an private key, greatly decreasing the chance of copying error, much like standard Bitcoin addresses.

1) Take a private key.

2) Add a 0x80 byte in front of it for mainnet addresses or 0xef for testnet addresses.

3) Append a 0x01 byte after it if it should be used with compressed public keys (described in a later subsection). Nothing is appended if it is used with uncompressed public keys.

4) Perform a SHA-256 hash on the extended key.

5) Perform a SHA-256 hash on result of SHA-256 hash.

6) Take the first four bytes of the second SHA-256 hash; this is the checksum.

7) Add the four checksum bytes from point 5 at the end of the extended key from point 2.

8) Convert the result from a byte string into a Base58 string using Base58Check encoding.

The process is easily reversible, using the Base58 decoding function, and removing the padding.

Hm. I'll rewrite this with a focus on the main Bitcoin network and uncompressed public keys.

Generating the WIF form of a private key:

1) Obtain a valid private key (i.e. within the input domain of the secp256k1 elliptic curve).

2) Add a 0x80 byte in front of the result of step (1).

3) Hash the result of step (2) using the SHA256 algorithm.

4) Hash the result of step (3) using the SHA256 algorithm.

5) Select the first four bytes of step (4). This is the checksum.

6) Append the result of step (5) to the result of step (2).

7) Treating the result of step (6) as a single big-endian bignumber, convert it to base-58 using bignumber division.

Note: The input for step (7) (i.e. the result of step (6)) should never have any leading zeros, because in step (2) a non-zero byte was used as a prefix. It's not necessary to count leading zeros and pad the final result with '1' characters.

Let's proceed.

1) Obtain a valid private key (i.e. within the input domain of the secp256k1 elliptic curve).

Private key: hello_world
Private key in hex: 68656c6c6f5f776f726c64

Result of step (1) is:
68656c6c6f5f776f726c64

2) Add a 0x80 byte in front of the result of step (1).

80 + 68656c6c6f5f776f726c64 = 8068656c6c6f5f776f726c64

Result of step (2) is:
8068656c6c6f5f776f726c64

Next:
3) Hash the result of step (2) using the SHA256 algorithm.
and
4) Hash the result of step (3) using the SHA256 algorithm.

>>> from pypy_sha256 import sha256
>>> from binascii import hexlify, unhexlify
>>> private_key_hex = "8068656c6c6f5f776f726c64"
>>> private_key_byte_string = unhexlify(private_key_hex)
>>> digest = sha256(private_key_byte_string).digest()
>>> digest2 = sha256(digest).digest()
>>> result = hexlify(digest2)
>>> print result
>>> 78adee1b9610dd005faef2f274a18e73e75bfe75ad33f0227753bb1bbd214693

Result of step (4) is:
78adee1b9610dd005faef2f274a18e73e75bfe75ad33f0227753bb1bbd214693

5) Select the first four bytes of step (4). This is the checksum.

Result of step (5) is:
78adee1b

6) Append the result of step (5) to the result of step (2).

8068656c6c6f5f776f726c64 + 78adee1b = 8068656c6c6f5f776f726c6478adee1b

Result of step (6) is:
8068656c6c6f5f776f726c6478adee1b

7) Treating the result of step (6) as a single big-endian bignumber, convert it to base-58 using bignumber division.

>>> int("8068656c6c6f5f776f726c6478adee1b", 16)
>>> 170683239447327396819007263021982412315L

Remove last 'L' character:
170683239447327396819007263021982412315

Use this decimal number as the input to:
convert_from_base_10_to_base_58.py

aineko:work stjohnpiano$ ./convert_from_base_10_to_base_58.py

input: 170683239447327396819007263021982412315
output: GrfjeystU3GdWTnAw7ofMk

Result of step (7) is:
GrfjeystU3GdWTnAw7ofMk

So:

Private key: hello_world
Private key in hex: 68656c6c6f5f776f726c64
Private key in WIF form: GrfjeystU3GdWTnAw7ofMk

Next: Import the private key in WIF form into a wallet program. Send the bitcoin stored in that address to my LocalBitcoins receiving address.

As far as I know, LocalBitcoins does not have an import-private-key option, so I need to find another wallet program.

I'll use my blockchain.info webwallet.

I wouldn't import a private key to a webwallet if the private key had a lot of bitcoin associated with it, but I'm willing to do so when only a relatively small amount is at risk. The main goal at the moment is to see if I can retrieve bitcoin from the address that I generated earlier.

Note: LocalBitcoins is of course a webwallet, and I do hold some bitcoin* there. This is an unprincipled exception to my assertion that I wouldn't use a webwallet to handle more than a relatively small amount of bitcoin. However, it should hopefully be only a temporary exception, as one of the purposes of this project is to proceed towards securely transferring this bitcoin off LocalBitcoins and onto paper.

* More precisely, I hold credits on the LocalBitcoins system, which LocalBitcoins promises to redeem for actual bitcoin when and if I send it to a Bitcoin address.

When I last tested it, the blockchain.info webwallet was not usable on this machine ("Aineko", running Mac 10.6.8) on either Chrome (Version 49.0.2623.112 (64-bit)) or Firefox (48.0.2).
- Chrome notes that: "This computer will no longer receive Google Chrome updates because Mac OS X 10.6, 10.7, and 10.8 are no longer supported."

It was usable on a Lenovo Thinkpad x200, running Windows 7 Professional (Service Pack 1), on Chrome (Version 65.0.3325.18 (64-bit)).

Boot up the x200.

Log in to blockchain.info webwallet.

Hm. It looks as though blockchain.info has removed the import-private-key functionality.

I'll have a look at Multibit (version 0.5.18). It's a wallet program installed on Aineko.

For importing private keys, Multibit expects a file with the extension .key.

# KEEP YOUR PRIVATE KEYS SAFE !
# Anyone who can read this file can spend your bitcoin.
#
# Format:
# <Base58 encoded private key>[<whitespace>[<key createdAt>]]
#
# The Base58 encoded private keys are the same format as
# produced by the Satoshi client/ sipa dumpprivkey utility.
#
# Key createdAt is in UTC format as specified by ISO 8601
# e.g: 2011-12-31T16:42:00Z . The century, 'T' and 'Z' are mandatory
#
GrfjeystU3GdWTnAw7ofMk 2017-02-20T18:24:23Z
# End of private keys

Here, I have simply used a previous Multibit export file and replaced the private key with the private key GrfjeystU3GdWTnAw7ofMk. I haven't altered the date information.

Result of importing this file:
{The private keys unlock failed. The error was "Could not understand address in import file".}

Hm.

Hypothesis: In step (1), the private key should have had leading zero bytes added to it until it was 256 bits (32 bytes) long. This would cause step (2) to produce a very different result.
- The ECDSA library accepted an integer for creating a SigningKey, so the lack of leading zeros for the private key wasn't a problem when I was generating the public Bitcoin address.

Let's try again.

1) Obtain a valid private key (i.e. within the input domain of the secp256k1 elliptic curve).

Private key: hello_world
Private key in hex: 68656c6c6f5f776f726c64
Number of bytes in private key: 11
Add (32-11=) 21 zero bytes in front of the private key:
21*"00" + 68656c6c6f5f776f726c64 =
00000000000000000000000000000000000000000068656c6c6f5f776f726c64

Result of step (1) is:
00000000000000000000000000000000000000000068656c6c6f5f776f726c64

2) Add a 0x80 byte in front of the result of step (1).

80 +
00000000000000000000000000000000000000000068656c6c6f5f776f726c64 =
8000000000000000000000000000000000000000000068656c6c6f5f776f726c64

Result of step (2) is:
8000000000000000000000000000000000000000000068656c6c6f5f776f726c64

Next:
3) Hash the result of step (2) using the SHA256 algorithm.
and
4) Hash the result of step (3) using the SHA256 algorithm.

>>> from pypy_sha256 import sha256
>>> from binascii import hexlify, unhexlify
>>> private_key_hex = "8000000000000000000000000000000000000000000068656c6c6f5f776f726c64"
>>> private_key_byte_string = unhexlify(private_key_hex)
>>> digest = sha256(private_key_byte_string).digest()
>>> digest2 = sha256(digest).digest()
>>> result = hexlify(digest2)
>>> print result
>>> 392c52c622d9cc8212e06d4a091bf2aec9c23014ed6bb5f1ef6224c7b9565a88

Result of step (4) is:
392c52c622d9cc8212e06d4a091bf2aec9c23014ed6bb5f1ef6224c7b9565a88

5) Select the first four bytes of step (4). This is the checksum.

Result of step (5) is:
392c52c6

6) Append the result of step (5) to the result of step (2).

8000000000000000000000000000000000000000000068656c6c6f5f776f726c64 + 392c52c6 =
8000000000000000000000000000000000000000000068656c6c6f5f776f726c64392c52c6

Result of step (6) is:
8000000000000000000000000000000000000000000068656c6c6f5f776f726c64392c52c6

7) Treating the result of step (6) as a single big-endian bignumber, convert it to base-58 using bignumber division.

>>> int("8068656c6c6f5f776f726c6478adee1b", 16)
>>> 63657374260452690195888927762793067532858387302060508374435375900489502937563577101079238L

Remove last 'L' character:
63657374260452690195888927762793067532858387302060508374435375900489502937563577101079238

Use this decimal number as the input to:
convert_from_base_10_to_base_58.py

aineko:work stjohnpiano$ ./convert_from_base_10_to_base_58.py

input: 63657374260452690195888927762793067532858387302060508374435375900489502937563577101079238
output: 5HpHagT65TZzG1PH3CSu63k8DbpvD8v17zAxKbSJNTwsxtFHvZK

Result of step (7) is:
5HpHagT65TZzG1PH3CSu63k8DbpvD8v17zAxKbSJNTwsxtFHvZK

So:

Private key: hello_world
Private key in hex: 68656c6c6f5f776f726c64
Private key in WIF form:
5HpHagT65TZzG1PH3CSu63k8DbpvD8v17zAxKbSJNTwsxtFHvZK

Let's try the import again.

# KEEP YOUR PRIVATE KEYS SAFE !
# Anyone who can read this file can spend your bitcoin.
#
# Format:
# <Base58 encoded private key>[<whitespace>[<key createdAt>]]
#
# The Base58 encoded private keys are the same format as
# produced by the Satoshi client/ sipa dumpprivkey utility.
#
# Key createdAt is in UTC format as specified by ISO 8601
# e.g: 2011-12-31T16:42:00Z . The century, 'T' and 'Z' are mandatory
#
5HpHagT65TZzG1PH3CSu63k8DbpvD8v17zAxKbSJNTwsxtFHvZK 2017-02-20T18:24:23Z
# End of private keys

Result of importing this file:
{Importing private keys... completed successfully}

Cool.

Multibit is currently trying to synchronise with the network.

It doesn't store a local copy of the blockchain, but it does need to request lots of information from a server in order to know the balances of the addresses in its wallets.
- Given that the Multibit project appears to be no-longer-supported (so it's probable that no server is available), the client may be connecting to nodes in the Bitcoin network directly.

After about 15 minutes it's at 13% synchronised.

[two hours pass]

24% synchronised.

[two and bit hours pass]

24% synchronised.

Hm. It's stuck.

I'll try something else.

I remember reading that Electrum is a thin client (i.e. doesn't store the blockchain locally) that connects to dedicated servers that have re-indexed the blockchain. If the project is still operational, then it might solve my problem.

Note: Like a webwallet, I would not use a thin client for operating on more than a small amount of bitcoin. A thin client must operate on an internet-connected computer in order to connect to its servers.

Next:
- Read Electrum documentation. Is it possible to import a private key?

Google "electrum".

First result:
electrum.org

The main site has a "Documentation" tab. This directs me to:
docs.electrum.org

Browse to this address.

In the Frequently Asked Questions list, I see: "Can I import private keys from other Bitcoin clients?"

Excerpts from:
docs.electrum.org/en/latest/faq.html#can-i-import-private-keys-from-other-bitcoin-clients

Can I import private keys from other Bitcoin clients?

In Electrum 2.0, you cannot import private keys in a wallet that has a seed. You should sweep them instead.

If you want to import private keys and not sweep them, you need to create a special wallet that does not have a seed. For this, create a new wallet, select "restore", and instead of typing your seed, type a list of private keys, or a list of addresses if you want to create a watching-only wallet.

[image not included]

You will need to back up this wallet, because it cannot be recovered from a seed.

[...]

Sweeping private keys means to send all the bitcoins they control to an existing address in your wallet. The private keys you sweep do not become a part of your wallet. Instead, all the bitcoins they control are sent to an address that has been deterministically generated from your wallet seed.

Next:
- Set up a VM (virtual machine) instance on Digital Ocean (known as a "droplet" on Digital Ocean's system)
- Install Electrum requirements
- Install Electrum

Excerpts from:
electrum.org/#download

Sources and executables are signed by ThomasV
[ http://pgp.mit.edu/pks/lookup?op=vindex&search=0x2BD5824B7F9470E6 ].

[...]

Installation from Python sources

Sources:
- Electrum-3.1.3.tar.gz (signature)
- Electrum-3.1.3.zip (signature)

Linux:
- Download and untar Electrum-3.1.3.tar.gz
- In the electrum directory, run: 'python3 electrum'
- To install it on your system, run: 'sudo python3 setup.py install'

Log in to Digital Ocean.

Click Create / Droplets.

Droplet details:
- Debian 9.4 x64
- Standard Droplet: 2 GB Memory, 1 vCPU, 50 GB SSD Disk, 2 TB Transfer, $10/mo ($0.015/hr).
- Datacentre region: Toronto
- SSH key: Tick "aineko" (existing key)
- hostname: test1

Droplet created.
IP address = 167.99.188.209

Get a new domain (edgecase-test.net).
Add it to my Digital Ocean account.
On the registrar service, set the nameservers of this domain to be the Digital Ocean nameservers.

Excerpt from:
www.digitalocean.com/community/tutorials/how-to-point-to-digitalocean-nameservers-from-common-domain-registrars
Authors: Josh Barnett, Kathleen Juell
Date: February 22, 2018

It will take some time for the name server changes to propagate after you've saved them. During this time, the domain registrar communicates the changes you've made with your ISP (Internet Service Provider). In turn, your ISP caches the new nameservers to ensure quick site connections. This process usually takes about 30 minutes, but could take up to a few hours depending on your registrar and your ISP's communication methods.

In the meantime, I can use the IP address directly.

aineko:~ stjohnpiano$ ssh root@167.99.188.209

The authenticity of host '167.99.188.209 (167.99.188.209)' can't be established.
RSA key fingerprint is b2:b5:5d:21:cd:fc:84:04:15:bc:14:d4:3a:1e:d2:9f.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added '167.99.188.209' (RSA) to the list of known hosts.
Linux test1 4.9.0-6-amd64 #1 SMP Debian 4.9.88-1+deb9u1 (2018-05-07) x86_64

The programs included with the Debian GNU/Linux system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.

Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
permitted by applicable law.

root@test1:~#

Ok.

Next:
- Download ThomasV's key.
- Download the Electrum tarball and verify its signature.

root@test1:~# gpg -- version

gpg: directory '/root/.gnupg' created
gpg: keybox '/root/.gnupg/pubring.kbx' created
gpg: WARNING: no command supplied. Trying to guess what you mean ...
gpg: can't open 'version'

root@test1:~# gpg --version

gpg (GnuPG) 2.1.18 libgcrypt 1.7.6-beta Copyright (C) 2017 Free Software Foundation, Inc. License GPLv3+: GNU GPL version 3 or later <https://gnu.org/licenses/gpl.html> This is free software: you are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law. Home: /root/.gnupg Supported algorithms: Pubkey: RSA, ELG, DSA, ECDH, ECDSA, EDDSA Cipher: IDEA, 3DES, CAST5, BLOWFISH, AES, AES192, AES256, TWOFISH, CAMELLIA128, CAMELLIA192, CAMELLIA256 Hash: SHA1, RIPEMD160, SHA256, SHA384, SHA512, SHA224 Compression: Uncompressed, ZIP, ZLIB, BZIP2

Browse to
pgp.mit.edu/pks/lookup?op=vindex&search=0x2BD5824B7F9470E6

Result:
{Service Temporarily Unavailable
The server is temporarily unable to service your request due to maintenance downtime or capacity problems. Please try again later.}

I see that the link is a search for "0x2BD5824B7F9470E6", which is presumably the key fingerprint.

Google "pgp mit"

First result:
pgp.mit.edu

Browse to this address.
A page with various search options loads.

Enter "0x2BD5824B7F9470E6" in the Search String field and click "Do the search!".

Result:
- 1 key:
-- Type = pub
-- bits/keyID = 4096R/7F9470E6
-- Date = 2011-06-15
-- User ID = ThomasV <thomasv1@gmx.de>
--- Also: Thomas Voegtlin <thomasv1@gmx.de>
--- Also: Thomas Voegtlin (https://electrum.org) <thomasv@electrum.org>

"7F9470E6" links to:
pgp.mit.edu/pks/lookup?op=get&search=0x2BD5824B7F9470E6

Browse to this address.

Result:
{Timeout
Request timed during request parsing after 2 seconds}

Google "pgp.mit.edu connection timed out".

Excerpt from first result:
pgp.mit.edu/faq.html

8. I can't look up keys on the keyserver, and may be seeing the error "connection timed out." However, I can read this FAQ.

The usual cause for this is that your machine is behind a firewall that is blocking traffic (on port 11371) to the keyserver, and are using an older cached URL. Please remove the ":11371" from the URL and try again. Alternately, you can try using the email interface
[ http://pgp.mit.edu/emailhelp.html ].

There's no :11371 in the URL
http://pgp.mit.edu/pks/lookup?op=get&search=0x2BD5824B7F9470E6

Google "pgp mit can't look up key"

Excerpt from:
futureboy.us/pgp.html

You can browse the keys available on keyservers at pgp.mit.edu or the often-slow sks-keyservers.net.

Browse to:
sks-keyservers.net

This links to:
sks-keyservers.net/status

Browse to this address.

Search on the page for pgp.mit.edu

It's listed under "Servers currently not in the pool".

The first entry under "Servers in the pool" is:
a.0.na.ispfontela.es
which links to:
a.0.na.ispfontela.es:11371

The Port 80 value for this entry is green (some others are red). I assume green means "working".

Browse to:
a.0.na.ispfontela.es:11371

Enter "0x2BD5824B7F9470E6" in the search field and click Extract Keys.

Result:
- 1 key:
-- Type = pub
-- bits/keyID = 4096R/7F9470E6
-- Date = 2011-06-15
-- User ID = ThomasV <thomasv1@gmx.de>
--- Also: Thomas Voegtlin <thomasv1@gmx.de>
--- Also: Thomas Voegtlin (https://electrum.org) <thomasv@electrum.org>

"7F9470E6" links to:
a.0.na.ispfontela.es:11371/pks/lookup?op=get&search=0x2BD5824B7F9470E6

Click this link.

Result:

-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: SKS 1.1.6
Comment: Hostname: a.0.na.ispfontela.es
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=
=VzZz
-----END PGP PUBLIC KEY BLOCK-----

I've saved this public key block as thomas_voegtlin_public_key.txt and added it as an asset to this article.

Note: It seems unusually long. It looks to me as though the public key block can store a lot more data than just the public key.
- I seem to remember reading somewhere that signatures-by-this-key-that-vouch-for-the-identity-of-other-keys are stored in the public key block.

root@test1:~# pwd

/root

root@test1:~# ls -1 /

bin
boot
dev
etc
home
initrd.img
initrd.img.old
lib
lib64
lost+found
media
mnt
opt
proc
root
run
sbin
srv
sys
tmp
usr
var
vmlinuz
vmlinuz.old

root@test1:~# cd /home

root@test1:/home# mkdir work

root@test1:~# cd work

root@test1:~# nano thomasv.public_key

Copy and paste the public key found above, being careful to not include any surrounding whitespace.

In nano, save the file and exit.

root@test1:~# gpg --import thomasv.public_key

gpg: /root/.gnupg/trustdb.gpg: trustdb created gpg: key 2BD5824B7F9470E6: public key "Thomas Voegtlin (https://electrum.org) <thomasv@electrum.org>" imported gpg: Total number processed: 1 gpg: imported: 1 gpg: no ultimately trusted keys found

Ok.

Next, get the source tarball onto the test machine.

On the page
electrum.org/#download
"Electrum-3.1.3.tar.gz" links to:
download.electrum.org/3.1.3/Electrum-3.1.3.tar.gz
and the corresponding "(signature)" links to:
download.electrum.org/3.1.3/Electrum-3.1.3.tar.gz.asc

root@test1:/home/work# curl --version

-bash: curl: command not found

root@test1:/home/work# wget --version

GNU Wget 1.18 built on linux-gnu. -cares +digest -gpgme +https +ipv6 +iri +large-file -metalink +nls +ntlm +opie +psl +ssl/gnutls Wgetrc: /etc/wgetrc (system) Locale: /usr/share/locale Compile: gcc -DHAVE_CONFIG_H -DSYSTEM_WGETRC="/etc/wgetrc" -DLOCALEDIR="/usr/share/locale" -I. -I../../src -I../lib -I../../lib -Wdate-time -D_FORTIFY_SOURCE=2 -I/usr/include -I/usr/include/p11-kit-1 -DHAVE_LIBGNUTLS -DNDEBUG -g -O2 -fdebug-prefix-map=/build/wget-N5RMXj/wget-1.18=. -fstack-protector-strong -Wformat -Werror=format-security -DNO_SSLv2 -D_FILE_OFFSET_BITS=64 -g -Wall Link: gcc -I/usr/include/p11-kit-1 -DHAVE_LIBGNUTLS -DNDEBUG -g -O2 -fdebug-prefix-map=/build/wget-N5RMXj/wget-1.18=. -fstack-protector-strong -Wformat -Werror=format-security -DNO_SSLv2 -D_FILE_OFFSET_BITS=64 -g -Wall -Wl,-z,relro -Wl,-z,now -L/usr/lib -lpcre -luuid -lnettle -lgnutls -lz -lpsl -lidn ftp-opie.o gnutls.o http-ntlm.o ../lib/libgnu.a Copyright (C) 2015 Free Software Foundation, Inc. License GPLv3+: GNU GPL version 3 or later <http://www.gnu.org/licenses/gpl.html>. This is free software: you are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law. Originally written by Hrvoje Niksic <hniksic@xemacs.org>. Please send bug reports and questions to <bug-wget@gnu.org>.

root@test1:/home/work# wget --version

root@test1:/home/work# wget http://download.electrum.org/3.1.3/Electrum-3.1.3.tar.gz

--2018-05-31 10:15:36-- http://download.electrum.org/3.1.3/Electrum-3.1.3.tar.gz
Resolving download.electrum.org (download.electrum.org)... 78.46.103.75
Connecting to download.electrum.org (download.electrum.org)|78.46.103.75|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 2806178 (2.7M) [application/x-gzip]
Saving to: [some non-ASCII byte values removed]Electrum-3.1.3.tar.gz[some non-ASCII byte values removed]

Electrum-3.1.3.tar. 100%[===================>] 2.68M 2.20MB/s in 1.2s

2018-05-31 10:15:38 (2.20 MB/s) - [some non-ASCII byte values removed]Electrum-3.1.3.tar.gz[some non-ASCII byte values removed] saved [2806178/2806178]

root@test1:/home/work# wget http://download.electrum.org/3.1.3/Electrum-3.1.3.tar.gz.asc

--2018-05-31 10:22:10-- http://download.electrum.org/3.1.3/Electrum-3.1.3.tar.gz.asc
Resolving download.electrum.org (download.electrum.org)... 78.46.103.75
Connecting to download.electrum.org (download.electrum.org)|78.46.103.75|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 801 [text/plain]
Saving to: [some non-ASCII byte values removed]Electrum-3.1.3.tar.gz.asc[some non-ASCII byte values removed]

Electrum-3.1.3.tar. 100%[===================>] 801 --.-KB/s in 0s

2018-05-31 10:22:11 (67.3 MB/s) - [some non-ASCII byte values removed]Electrum-3.1.3.tar.gz.asc[some non-ASCII byte values removed] saved [801/801]

Note the use of:
[some non-ASCII byte values removed]
This was not part of the original output.

root@test1:/home/work# ls -1

Electrum-3.1.3.tar.gz
Electrum-3.1.3.tar.gz.asc
thomasv.public_key

root@test1:/home/work# gpg --verify Electrum-3.1.3.tar.gz.asc Electrum-3.1.3.tar.gz

gpg: Signature made Wed 18 Apr 2018 03:10:44 PM UTC gpg: using RSA key 2BD5824B7F9470E6 gpg: Good signature from "Thomas Voegtlin (https://electrum.org) <thomasv@electrum.org>" [unknown] gpg: aka "ThomasV <thomasv1@gmx.de>" [unknown] gpg: aka "Thomas Voegtlin <thomasv1@gmx.de>" [unknown] gpg: WARNING: This key is not certified with a trusted signature! gpg: There is no indication that the signature belongs to the owner. Primary key fingerprint: 6694 D8DE 7BE8 EE56 31BE D950 2BD5 824B 7F94 70E6

Good.

The important line is:

gpg: Good signature from "Thomas Voegtlin (https://electrum.org)

This indicates that GPG thinks the signature is valid.

Excerpt from:
electrum.org/#download

Linux:
- Download and untar Electrum-3.1.3.tar.gz
- In the electrum directory, run: 'python3 electrum'
- To install it on your system, run: 'sudo python3 setup.py install'

root@test1:/home/work# tar -zxvf Electrum-3.1.3.tar.gz

Electrum-3.1.3/
Electrum-3.1.3/contrib/
Electrum-3.1.3/contrib/requirements/
Electrum-3.1.3/contrib/requirements/requirements-hw.txt
Electrum-3.1.3/contrib/requirements/requirements.txt
Electrum-3.1.3/icons/
Electrum-3.1.3/icons/clock5.png
Electrum-3.1.3/icons/status_connected.png
Electrum-3.1.3/icons/key.png
Electrum-3.1.3/icons/clock4.png
Electrum-3.1.3/icons/preferences.png
Electrum-3.1.3/icons/unconfirmed.png
Electrum-3.1.3/icons/expired.png
Electrum-3.1.3/icons/unconfirmed.svg
Electrum-3.1.3/icons/tab_receive.png
Electrum-3.1.3/icons/seal.png
Electrum-3.1.3/icons/ledger_unpaired.png
Electrum-3.1.3/icons/speaker.png
Electrum-3.1.3/icons/tor_logo.png
Electrum-3.1.3/icons/tab_console.png
Electrum-3.1.3/icons/electrum_dark_icon.png
Electrum-3.1.3/icons/tab_addresses.png
Electrum-3.1.3/icons/ledger.png
Electrum-3.1.3/icons/digitalbitbox_unpaired.png
Electrum-3.1.3/icons/seed.png
Electrum-3.1.3/icons/status_disconnected.png
Electrum-3.1.3/icons/keepkey_unpaired.png
Electrum-3.1.3/icons/unlock.svg
Electrum-3.1.3/icons/qrcode.png
Electrum-3.1.3/icons/network.png
Electrum-3.1.3/icons/electrum_launcher.png
Electrum-3.1.3/icons/clock1.png
Electrum-3.1.3/icons/info.png
Electrum-3.1.3/icons/status_waiting.svg
Electrum-3.1.3/icons/confirmed.png
Electrum-3.1.3/icons/lock.svg
Electrum-3.1.3/icons/unlock.png
Electrum-3.1.3/icons/electrum_presplash.png
Electrum-3.1.3/icons/zoom.png
Electrum-3.1.3/icons/electrum.png
Electrum-3.1.3/icons/clock2.png
Electrum-3.1.3/icons/lock.png
Electrum-3.1.3/icons/status_waiting.png
Electrum-3.1.3/icons/tab_send.png
Electrum-3.1.3/icons/trezor.png
Electrum-3.1.3/icons/keepkey.png
Electrum-3.1.3/icons/copy.png
Electrum-3.1.3/icons/trustedcoin-status.png
Electrum-3.1.3/icons/tab_coins.png
Electrum-3.1.3/icons/trustedcoin-wizard.png
Electrum-3.1.3/icons/offline_tx.png
Electrum-3.1.3/icons/unpaid.png
Electrum-3.1.3/icons/status_disconnected.svg
Electrum-3.1.3/icons/status_lagging.png
Electrum-3.1.3/icons/tab_history.png
Electrum-3.1.3/icons/digitalbitbox.png
Electrum-3.1.3/icons/microphone.png
Electrum-3.1.3/icons/trezor_unpaired.png
Electrum-3.1.3/icons/qrcode_white.png
Electrum-3.1.3/icons/status_connected_proxy.png
Electrum-3.1.3/icons/tab_contacts.png
Electrum-3.1.3/icons/warning.png
Electrum-3.1.3/icons/clock3.png
Electrum-3.1.3/icons/file.png
Electrum-3.1.3/icons/electrum.ico
Electrum-3.1.3/icons/electrum_light_icon.png
Electrum-3.1.3/electrum
Electrum-3.1.3/MANIFEST.in
Electrum-3.1.3/packages/
Electrum-3.1.3/packages/chardet/
Electrum-3.1.3/packages/chardet/langbulgarianmodel.py
Electrum-3.1.3/packages/chardet/__init__.py
Electrum-3.1.3/packages/chardet/enums.py
Electrum-3.1.3/packages/chardet/gb2312freq.py
Electrum-3.1.3/packages/chardet/compat.py
Electrum-3.1.3/packages/chardet/codingstatemachine.py
Electrum-3.1.3/packages/chardet/escprober.py
Electrum-3.1.3/packages/chardet/langcyrillicmodel.py
Electrum-3.1.3/packages/chardet/escsm.py
Electrum-3.1.3/packages/chardet/jisfreq.py
Electrum-3.1.3/packages/chardet/latin1prober.py
Electrum-3.1.3/packages/chardet/euckrfreq.py
Electrum-3.1.3/packages/chardet/sbcsgroupprober.py
Electrum-3.1.3/packages/chardet/hebrewprober.py
Electrum-3.1.3/packages/chardet/chardistribution.py
Electrum-3.1.3/packages/chardet/mbcharsetprober.py
Electrum-3.1.3/packages/chardet/big5prober.py
Electrum-3.1.3/packages/chardet/utf8prober.py
Electrum-3.1.3/packages/chardet/gb2312prober.py
Electrum-3.1.3/packages/chardet/cli/
Electrum-3.1.3/packages/chardet/cli/__init__.py
Electrum-3.1.3/packages/chardet/cli/chardetect.py
Electrum-3.1.3/packages/chardet/langthaimodel.py
Electrum-3.1.3/packages/chardet/langhungarianmodel.py
Electrum-3.1.3/packages/chardet/euckrprober.py
Electrum-3.1.3/packages/chardet/mbcsgroupprober.py
Electrum-3.1.3/packages/chardet/big5freq.py
Electrum-3.1.3/packages/chardet/jpcntx.py
Electrum-3.1.3/packages/chardet/euctwfreq.py
Electrum-3.1.3/packages/chardet/euctwprober.py
Electrum-3.1.3/packages/chardet/universaldetector.py
Electrum-3.1.3/packages/chardet/eucjpprober.py
Electrum-3.1.3/packages/chardet/langhebrewmodel.py
Electrum-3.1.3/packages/chardet/charsetgroupprober.py
Electrum-3.1.3/packages/chardet/cp949prober.py
Electrum-3.1.3/packages/chardet/charsetprober.py
Electrum-3.1.3/packages/chardet/sbcharsetprober.py
Electrum-3.1.3/packages/chardet/sjisprober.py
Electrum-3.1.3/packages/chardet/langturkishmodel.py
Electrum-3.1.3/packages/chardet/langgreekmodel.py
Electrum-3.1.3/packages/chardet/version.py
Electrum-3.1.3/packages/chardet/mbcssm.py
Electrum-3.1.3/packages/sockshandler.py
Electrum-3.1.3/packages/ecdsa/
Electrum-3.1.3/packages/ecdsa/__init__.py
Electrum-3.1.3/packages/ecdsa/util.py
Electrum-3.1.3/packages/ecdsa/ecdsa.py
Electrum-3.1.3/packages/ecdsa/_version.py
Electrum-3.1.3/packages/ecdsa/ellipticcurve.py
Electrum-3.1.3/packages/ecdsa/curves.py
Electrum-3.1.3/packages/ecdsa/test_pyecdsa.py
Electrum-3.1.3/packages/ecdsa/rfc6979.py
Electrum-3.1.3/packages/ecdsa/six.py
Electrum-3.1.3/packages/ecdsa/numbertheory.py
Electrum-3.1.3/packages/ecdsa/keys.py
Electrum-3.1.3/packages/ecdsa/der.py
Electrum-3.1.3/packages/certifi/
Electrum-3.1.3/packages/certifi/__init__.py
Electrum-3.1.3/packages/certifi/__main__.py
Electrum-3.1.3/packages/certifi/cacert.pem
Electrum-3.1.3/packages/certifi/core.py
Electrum-3.1.3/packages/setuptools/
Electrum-3.1.3/packages/setuptools/__init__.py
Electrum-3.1.3/packages/setuptools/py27compat.py
Electrum-3.1.3/packages/setuptools/namespaces.py
Electrum-3.1.3/packages/setuptools/unicode_utils.py
Electrum-3.1.3/packages/setuptools/lib2to3_ex.py
Electrum-3.1.3/packages/setuptools/py36compat.py
Electrum-3.1.3/packages/setuptools/launch.py
Electrum-3.1.3/packages/setuptools/config.py
Electrum-3.1.3/packages/setuptools/depends.py
Electrum-3.1.3/packages/setuptools/sandbox.py
Electrum-3.1.3/packages/setuptools/wheel.py
Electrum-3.1.3/packages/setuptools/_vendor/
Electrum-3.1.3/packages/setuptools/_vendor/__init__.py
Electrum-3.1.3/packages/setuptools/_vendor/packaging/
Electrum-3.1.3/packages/setuptools/_vendor/packaging/__init__.py
Electrum-3.1.3/packages/setuptools/_vendor/packaging/_compat.py
Electrum-3.1.3/packages/setuptools/_vendor/packaging/utils.py
Electrum-3.1.3/packages/setuptools/_vendor/packaging/requirements.py
Electrum-3.1.3/packages/setuptools/_vendor/packaging/markers.py
Electrum-3.1.3/packages/setuptools/_vendor/packaging/specifiers.py
Electrum-3.1.3/packages/setuptools/_vendor/packaging/_structures.py
Electrum-3.1.3/packages/setuptools/_vendor/packaging/__about__.py
Electrum-3.1.3/packages/setuptools/_vendor/packaging/version.py
Electrum-3.1.3/packages/setuptools/_vendor/pyparsing.py
Electrum-3.1.3/packages/setuptools/_vendor/six.py
Electrum-3.1.3/packages/setuptools/dep_util.py
Electrum-3.1.3/packages/setuptools/archive_util.py
Electrum-3.1.3/packages/setuptools/py33compat.py
Electrum-3.1.3/packages/setuptools/package_index.py
Electrum-3.1.3/packages/setuptools/site-patch.py
Electrum-3.1.3/packages/setuptools/windows_support.py
Electrum-3.1.3/packages/setuptools/extension.py
Electrum-3.1.3/packages/setuptools/ssl_support.py
Electrum-3.1.3/packages/setuptools/dist.py
Electrum-3.1.3/packages/setuptools/monkey.py
Electrum-3.1.3/packages/setuptools/glob.py
Electrum-3.1.3/packages/setuptools/build_meta.py
Electrum-3.1.3/packages/setuptools/glibc.py
Electrum-3.1.3/packages/setuptools/pep425tags.py
Electrum-3.1.3/packages/setuptools/py31compat.py
Electrum-3.1.3/packages/setuptools/command/
Electrum-3.1.3/packages/setuptools/command/bdist_wininst.py
Electrum-3.1.3/packages/setuptools/command/develop.py
Electrum-3.1.3/packages/setuptools/command/__init__.py
Electrum-3.1.3/packages/setuptools/command/install_scripts.py
Electrum-3.1.3/packages/setuptools/command/py36compat.py
Electrum-3.1.3/packages/setuptools/command/bdist_egg.py
Electrum-3.1.3/packages/setuptools/command/sdist.py
Electrum-3.1.3/packages/setuptools/command/dist_info.py
Electrum-3.1.3/packages/setuptools/command/build_clib.py
Electrum-3.1.3/packages/setuptools/command/build_py.py
Electrum-3.1.3/packages/setuptools/command/egg_info.py
Electrum-3.1.3/packages/setuptools/command/test.py
Electrum-3.1.3/packages/setuptools/command/install_egg_info.py
Electrum-3.1.3/packages/setuptools/command/install_lib.py
Electrum-3.1.3/packages/setuptools/command/saveopts.py
Electrum-3.1.3/packages/setuptools/command/build_ext.py
Electrum-3.1.3/packages/setuptools/command/alias.py
Electrum-3.1.3/packages/setuptools/command/bdist_rpm.py
Electrum-3.1.3/packages/setuptools/command/upload_docs.py
Electrum-3.1.3/packages/setuptools/command/install.py
Electrum-3.1.3/packages/setuptools/command/upload.py
Electrum-3.1.3/packages/setuptools/command/setopt.py
Electrum-3.1.3/packages/setuptools/command/rotate.py
Electrum-3.1.3/packages/setuptools/command/easy_install.py
Electrum-3.1.3/packages/setuptools/command/register.py
Electrum-3.1.3/packages/setuptools/msvc.py
Electrum-3.1.3/packages/setuptools/version.py
Electrum-3.1.3/packages/setuptools/extern/
Electrum-3.1.3/packages/setuptools/extern/__init__.py
Electrum-3.1.3/packages/urllib3/
Electrum-3.1.3/packages/urllib3/__init__.py
Electrum-3.1.3/packages/urllib3/connection.py
Electrum-3.1.3/packages/urllib3/contrib/
Electrum-3.1.3/packages/urllib3/contrib/__init__.py
Electrum-3.1.3/packages/urllib3/contrib/pyopenssl.py
Electrum-3.1.3/packages/urllib3/contrib/ntlmpool.py
Electrum-3.1.3/packages/urllib3/contrib/securetransport.py
Electrum-3.1.3/packages/urllib3/contrib/_securetransport/
Electrum-3.1.3/packages/urllib3/contrib/_securetransport/__init__.py
Electrum-3.1.3/packages/urllib3/contrib/_securetransport/bindings.py
Electrum-3.1.3/packages/urllib3/contrib/_securetransport/low_level.py
Electrum-3.1.3/packages/urllib3/contrib/appengine.py
Electrum-3.1.3/packages/urllib3/contrib/socks.py
Electrum-3.1.3/packages/urllib3/_collections.py
Electrum-3.1.3/packages/urllib3/response.py
Electrum-3.1.3/packages/urllib3/poolmanager.py
Electrum-3.1.3/packages/urllib3/util/
Electrum-3.1.3/packages/urllib3/util/__init__.py
Electrum-3.1.3/packages/urllib3/util/connection.py
Electrum-3.1.3/packages/urllib3/util/timeout.py
Electrum-3.1.3/packages/urllib3/util/response.py
Electrum-3.1.3/packages/urllib3/util/wait.py
Electrum-3.1.3/packages/urllib3/util/url.py
Electrum-3.1.3/packages/urllib3/util/retry.py
Electrum-3.1.3/packages/urllib3/util/request.py
Electrum-3.1.3/packages/urllib3/util/selectors.py
Electrum-3.1.3/packages/urllib3/util/ssl_.py
Electrum-3.1.3/packages/urllib3/packages/
Electrum-3.1.3/packages/urllib3/packages/__init__.py
Electrum-3.1.3/packages/urllib3/packages/ordered_dict.py
Electrum-3.1.3/packages/urllib3/packages/backports/
Electrum-3.1.3/packages/urllib3/packages/backports/__init__.py
Electrum-3.1.3/packages/urllib3/packages/backports/makefile.py
Electrum-3.1.3/packages/urllib3/packages/ssl_match_hostname/
Electrum-3.1.3/packages/urllib3/packages/ssl_match_hostname/__init__.py
Electrum-3.1.3/packages/urllib3/packages/ssl_match_hostname/_implementation.py
Electrum-3.1.3/packages/urllib3/packages/six.py
Electrum-3.1.3/packages/urllib3/exceptions.py
Electrum-3.1.3/packages/urllib3/filepost.py
Electrum-3.1.3/packages/urllib3/request.py
Electrum-3.1.3/packages/urllib3/connectionpool.py
Electrum-3.1.3/packages/urllib3/fields.py
Electrum-3.1.3/packages/jsonrpclib/
Electrum-3.1.3/packages/jsonrpclib/__init__.py
Electrum-3.1.3/packages/jsonrpclib/utils.py
Electrum-3.1.3/packages/jsonrpclib/config.py
Electrum-3.1.3/packages/jsonrpclib/jsonclass.py
Electrum-3.1.3/packages/jsonrpclib/SimpleJSONRPCServer.py
Electrum-3.1.3/packages/jsonrpclib/jsonrpc.py
Electrum-3.1.3/packages/jsonrpclib/threadpool.py
Electrum-3.1.3/packages/jsonrpclib/history.py
Electrum-3.1.3/packages/requests/
Electrum-3.1.3/packages/requests/__init__.py
Electrum-3.1.3/packages/requests/models.py
Electrum-3.1.3/packages/requests/utils.py
Electrum-3.1.3/packages/requests/certs.py
Electrum-3.1.3/packages/requests/sessions.py
Electrum-3.1.3/packages/requests/compat.py
Electrum-3.1.3/packages/requests/exceptions.py
Electrum-3.1.3/packages/requests/cookies.py
Electrum-3.1.3/packages/requests/_internal_utils.py
Electrum-3.1.3/packages/requests/status_codes.py
Electrum-3.1.3/packages/requests/structures.py
Electrum-3.1.3/packages/requests/__version__.py
Electrum-3.1.3/packages/requests/api.py
Electrum-3.1.3/packages/requests/adapters.py
Electrum-3.1.3/packages/requests/packages.py
Electrum-3.1.3/packages/requests/hooks.py
Electrum-3.1.3/packages/requests/auth.py
Electrum-3.1.3/packages/requests/help.py
Electrum-3.1.3/packages/pyaes/
Electrum-3.1.3/packages/pyaes/__init__.py
Electrum-3.1.3/packages/pyaes/util.py
Electrum-3.1.3/packages/pyaes/aes.py
Electrum-3.1.3/packages/pyaes/blockfeeder.py
Electrum-3.1.3/packages/pkg_resources/
Electrum-3.1.3/packages/pkg_resources/__init__.py
Electrum-3.1.3/packages/pkg_resources/_vendor/
Electrum-3.1.3/packages/pkg_resources/_vendor/__init__.py
Electrum-3.1.3/packages/pkg_resources/_vendor/appdirs.py
Electrum-3.1.3/packages/pkg_resources/_vendor/packaging/
Electrum-3.1.3/packages/pkg_resources/_vendor/packaging/__init__.py
Electrum-3.1.3/packages/pkg_resources/_vendor/packaging/_compat.py
Electrum-3.1.3/packages/pkg_resources/_vendor/packaging/utils.py
Electrum-3.1.3/packages/pkg_resources/_vendor/packaging/requirements.py
Electrum-3.1.3/packages/pkg_resources/_vendor/packaging/markers.py
Electrum-3.1.3/packages/pkg_resources/_vendor/packaging/specifiers.py
Electrum-3.1.3/packages/pkg_resources/_vendor/packaging/_structures.py
Electrum-3.1.3/packages/pkg_resources/_vendor/packaging/__about__.py
Electrum-3.1.3/packages/pkg_resources/_vendor/packaging/version.py
Electrum-3.1.3/packages/pkg_resources/_vendor/pyparsing.py
Electrum-3.1.3/packages/pkg_resources/_vendor/six.py
Electrum-3.1.3/packages/pkg_resources/py31compat.py
Electrum-3.1.3/packages/pkg_resources/extern/
Electrum-3.1.3/packages/pkg_resources/extern/__init__.py
Electrum-3.1.3/packages/dns/
Electrum-3.1.3/packages/dns/entropy.py
Electrum-3.1.3/packages/dns/namedict.py
Electrum-3.1.3/packages/dns/hash.py
Electrum-3.1.3/packages/dns/__init__.py
Electrum-3.1.3/packages/dns/_compat.py
Electrum-3.1.3/packages/dns/tokenizer.py
Electrum-3.1.3/packages/dns/reversename.py
Electrum-3.1.3/packages/dns/rdatatype.py
Electrum-3.1.3/packages/dns/dnssec.py
Electrum-3.1.3/packages/dns/resolver.py
Electrum-3.1.3/packages/dns/rdata.py
Electrum-3.1.3/packages/dns/ipv6.py
Electrum-3.1.3/packages/dns/rdataset.py
Electrum-3.1.3/packages/dns/tsigkeyring.py
Electrum-3.1.3/packages/dns/rdtypes/
Electrum-3.1.3/packages/dns/rdtypes/txtbase.py
Electrum-3.1.3/packages/dns/rdtypes/__init__.py
Electrum-3.1.3/packages/dns/rdtypes/IN/
Electrum-3.1.3/packages/dns/rdtypes/IN/DHCID.py
Electrum-3.1.3/packages/dns/rdtypes/IN/__init__.py
Electrum-3.1.3/packages/dns/rdtypes/IN/APL.py
Electrum-3.1.3/packages/dns/rdtypes/IN/SRV.py
Electrum-3.1.3/packages/dns/rdtypes/IN/NSAP.py
Electrum-3.1.3/packages/dns/rdtypes/IN/A.py
Electrum-3.1.3/packages/dns/rdtypes/IN/AAAA.py
Electrum-3.1.3/packages/dns/rdtypes/IN/KX.py
Electrum-3.1.3/packages/dns/rdtypes/IN/IPSECKEY.py
Electrum-3.1.3/packages/dns/rdtypes/IN/PX.py
Electrum-3.1.3/packages/dns/rdtypes/IN/NSAP_PTR.py
Electrum-3.1.3/packages/dns/rdtypes/IN/NAPTR.py
Electrum-3.1.3/packages/dns/rdtypes/IN/WKS.py
Electrum-3.1.3/packages/dns/rdtypes/dnskeybase.py
Electrum-3.1.3/packages/dns/rdtypes/dsbase.py
Electrum-3.1.3/packages/dns/rdtypes/nsbase.py
Electrum-3.1.3/packages/dns/rdtypes/euibase.py
Electrum-3.1.3/packages/dns/rdtypes/mxbase.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/
Electrum-3.1.3/packages/dns/rdtypes/ANY/LOC.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/__init__.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/TLSA.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/NSEC3.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/ISDN.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/AFSDB.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/EUI48.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/NSEC3PARAM.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/CSYNC.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/MX.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/SOA.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/CDS.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/HIP.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/CERT.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/NS.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/RP.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/DNAME.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/AVC.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/CNAME.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/RT.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/PTR.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/X25.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/CAA.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/GPOS.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/EUI64.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/HINFO.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/DLV.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/DNSKEY.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/DS.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/NSEC.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/RRSIG.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/URI.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/SPF.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/CDNSKEY.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/TXT.py
Electrum-3.1.3/packages/dns/rdtypes/ANY/SSHFP.py
Electrum-3.1.3/packages/dns/edns.py
Electrum-3.1.3/packages/dns/opcode.py
Electrum-3.1.3/packages/dns/zone.py
Electrum-3.1.3/packages/dns/message.py
Electrum-3.1.3/packages/dns/ipv4.py
Electrum-3.1.3/packages/dns/grange.py
Electrum-3.1.3/packages/dns/query.py
Electrum-3.1.3/packages/dns/tsig.py
Electrum-3.1.3/packages/dns/rcode.py
Electrum-3.1.3/packages/dns/renderer.py
Electrum-3.1.3/packages/dns/flags.py
Electrum-3.1.3/packages/dns/node.py
Electrum-3.1.3/packages/dns/rrset.py
Electrum-3.1.3/packages/dns/exception.py
Electrum-3.1.3/packages/dns/name.py
Electrum-3.1.3/packages/dns/wiredata.py
Electrum-3.1.3/packages/dns/ttl.py
Electrum-3.1.3/packages/dns/rdataclass.py
Electrum-3.1.3/packages/dns/e164.py
Electrum-3.1.3/packages/dns/update.py
Electrum-3.1.3/packages/dns/inet.py
Electrum-3.1.3/packages/dns/set.py
Electrum-3.1.3/packages/dns/version.py
Electrum-3.1.3/packages/idna/
Electrum-3.1.3/packages/idna/codec.py
Electrum-3.1.3/packages/idna/__init__.py
Electrum-3.1.3/packages/idna/compat.py
Electrum-3.1.3/packages/idna/package_data.py
Electrum-3.1.3/packages/idna/uts46data.py
Electrum-3.1.3/packages/idna/idnadata.py
Electrum-3.1.3/packages/idna/core.py
Electrum-3.1.3/packages/idna/intranges.py
Electrum-3.1.3/packages/six.py
Electrum-3.1.3/packages/socks.py
Electrum-3.1.3/packages/easy_install.py
Electrum-3.1.3/packages/qrcode/
Electrum-3.1.3/packages/qrcode/__init__.py
Electrum-3.1.3/packages/qrcode/speedy.py
Electrum-3.1.3/packages/qrcode/util.py
Electrum-3.1.3/packages/qrcode/exceptions.py
Electrum-3.1.3/packages/qrcode/constants.py
Electrum-3.1.3/packages/qrcode/main.py
Electrum-3.1.3/packages/qrcode/console_scripts.py
Electrum-3.1.3/packages/qrcode/base.py
Electrum-3.1.3/packages/qrcode/mecard.py
Electrum-3.1.3/packages/qrcode/image/
Electrum-3.1.3/packages/qrcode/image/__init__.py
Electrum-3.1.3/packages/qrcode/image/pil.py
Electrum-3.1.3/packages/qrcode/image/pure.py
Electrum-3.1.3/packages/qrcode/image/base.py
Electrum-3.1.3/packages/qrcode/image/svg.py
Electrum-3.1.3/packages/qrcode/tests/
Electrum-3.1.3/packages/qrcode/tests/__init__.py
Electrum-3.1.3/packages/qrcode/tests/test_script.py
Electrum-3.1.3/packages/qrcode/tests/test_qrcode.py
Electrum-3.1.3/packages/qrcode/tests/test_example.py
Electrum-3.1.3/packages/qrcode/tests/svg.py
Electrum-3.1.3/packages/pbkdf2.py
Electrum-3.1.3/packages/google/
Electrum-3.1.3/packages/google/protobuf/
Electrum-3.1.3/packages/google/protobuf/struct_pb2.py
Electrum-3.1.3/packages/google/protobuf/unittest_custom_options_pb2.py
Electrum-3.1.3/packages/google/protobuf/__init__.py
Electrum-3.1.3/packages/google/protobuf/proto_builder.py
Electrum-3.1.3/packages/google/protobuf/symbol_database.py
Electrum-3.1.3/packages/google/protobuf/unittest_import_pb2.py
Electrum-3.1.3/packages/google/protobuf/descriptor.py
Electrum-3.1.3/packages/google/protobuf/any_test_pb2.py
Electrum-3.1.3/packages/google/protobuf/descriptor_pool.py
Electrum-3.1.3/packages/google/protobuf/util/
Electrum-3.1.3/packages/google/protobuf/util/__init__.py
Electrum-3.1.3/packages/google/protobuf/util/json_format_proto3_pb2.py
Electrum-3.1.3/packages/google/protobuf/unittest_no_arena_pb2.py
Electrum-3.1.3/packages/google/protobuf/empty_pb2.py
Electrum-3.1.3/packages/google/protobuf/unittest_arena_pb2.py
Electrum-3.1.3/packages/google/protobuf/reflection.py
Electrum-3.1.3/packages/google/protobuf/pyext/
Electrum-3.1.3/packages/google/protobuf/pyext/__init__.py
Electrum-3.1.3/packages/google/protobuf/pyext/python_pb2.py
Electrum-3.1.3/packages/google/protobuf/pyext/cpp_message.py
Electrum-3.1.3/packages/google/protobuf/message.py
Electrum-3.1.3/packages/google/protobuf/text_format.py
Electrum-3.1.3/packages/google/protobuf/unittest_pb2.py
Electrum-3.1.3/packages/google/protobuf/test_messages_proto2_pb2.py
Electrum-3.1.3/packages/google/protobuf/descriptor_database.py
Electrum-3.1.3/packages/google/protobuf/type_pb2.py
Electrum-3.1.3/packages/google/protobuf/json_format.py
Electrum-3.1.3/packages/google/protobuf/wrappers_pb2.py
Electrum-3.1.3/packages/google/protobuf/service.py
Electrum-3.1.3/packages/google/protobuf/unittest_mset_pb2.py
Electrum-3.1.3/packages/google/protobuf/source_context_pb2.py
Electrum-3.1.3/packages/google/protobuf/internal/
Electrum-3.1.3/packages/google/protobuf/internal/symbol_database_test.py
Electrum-3.1.3/packages/google/protobuf/internal/__init__.py
Electrum-3.1.3/packages/google/protobuf/internal/well_known_types.py
Electrum-3.1.3/packages/google/protobuf/internal/any_test_pb2.py
Electrum-3.1.3/packages/google/protobuf/internal/containers.py
Electrum-3.1.3/packages/google/protobuf/internal/descriptor_pool_test1_pb2.py
Electrum-3.1.3/packages/google/protobuf/internal/json_format_test.py
Electrum-3.1.3/packages/google/protobuf/internal/api_implementation.py
Electrum-3.1.3/packages/google/protobuf/internal/file_options_test_pb2.py
Electrum-3.1.3/packages/google/protobuf/internal/more_messages_pb2.py
Electrum-3.1.3/packages/google/protobuf/internal/wire_format_test.py
Electrum-3.1.3/packages/google/protobuf/internal/packed_field_test_pb2.py
Electrum-3.1.3/packages/google/protobuf/internal/import_test_package/
Electrum-3.1.3/packages/google/protobuf/internal/import_test_package/__init__.py
Electrum-3.1.3/packages/google/protobuf/internal/import_test_package/outer_pb2.py
Electrum-3.1.3/packages/google/protobuf/internal/import_test_package/inner_pb2.py
Electrum-3.1.3/packages/google/protobuf/internal/descriptor_pool_test2_pb2.py
Electrum-3.1.3/packages/google/protobuf/internal/test_bad_identifiers_pb2.py
Electrum-3.1.3/packages/google/protobuf/internal/factory_test2_pb2.py
Electrum-3.1.3/packages/google/protobuf/internal/python_message.py
Electrum-3.1.3/packages/google/protobuf/internal/factory_test1_pb2.py
Electrum-3.1.3/packages/google/protobuf/internal/proto_builder_test.py
Electrum-3.1.3/packages/google/protobuf/internal/reflection_test.py
Electrum-3.1.3/packages/google/protobuf/internal/encoder.py
Electrum-3.1.3/packages/google/protobuf/internal/message_set_extensions_pb2.py
Electrum-3.1.3/packages/google/protobuf/internal/type_checkers.py
Electrum-3.1.3/packages/google/protobuf/internal/decoder.py
Electrum-3.1.3/packages/google/protobuf/internal/enum_type_wrapper.py
Electrum-3.1.3/packages/google/protobuf/internal/text_format_test.py
Electrum-3.1.3/packages/google/protobuf/internal/wire_format.py
Electrum-3.1.3/packages/google/protobuf/internal/test_util.py
Electrum-3.1.3/packages/google/protobuf/internal/unknown_fields_test.py
Electrum-3.1.3/packages/google/protobuf/internal/message_listener.py
Electrum-3.1.3/packages/google/protobuf/internal/message_test.py
Electrum-3.1.3/packages/google/protobuf/internal/descriptor_database_test.py
Electrum-3.1.3/packages/google/protobuf/internal/service_reflection_test.py
Electrum-3.1.3/packages/google/protobuf/internal/missing_enum_values_pb2.py
Electrum-3.1.3/packages/google/protobuf/internal/well_known_types_test.py
Electrum-3.1.3/packages/google/protobuf/internal/text_encoding_test.py
Electrum-3.1.3/packages/google/protobuf/internal/_parameterized.py
Electrum-3.1.3/packages/google/protobuf/internal/more_extensions_pb2.py
Electrum-3.1.3/packages/google/protobuf/internal/descriptor_test.py
Electrum-3.1.3/packages/google/protobuf/internal/testing_refleaks.py
Electrum-3.1.3/packages/google/protobuf/internal/descriptor_pool_test.py
Electrum-3.1.3/packages/google/protobuf/internal/message_factory_test.py
Electrum-3.1.3/packages/google/protobuf/internal/more_extensions_dynamic_pb2.py
Electrum-3.1.3/packages/google/protobuf/internal/generator_test.py
Electrum-3.1.3/packages/google/protobuf/any_pb2.py
Electrum-3.1.3/packages/google/protobuf/descriptor_pb2.py
Electrum-3.1.3/packages/google/protobuf/map_proto2_unittest_pb2.py
Electrum-3.1.3/packages/google/protobuf/api_pb2.py
Electrum-3.1.3/packages/google/protobuf/text_encoding.py
Electrum-3.1.3/packages/google/protobuf/unittest_proto3_arena_pb2.py
Electrum-3.1.3/packages/google/protobuf/unittest_no_generic_services_pb2.py
Electrum-3.1.3/packages/google/protobuf/unittest_mset_wire_format_pb2.py
Electrum-3.1.3/packages/google/protobuf/unittest_no_arena_import_pb2.py
Electrum-3.1.3/packages/google/protobuf/map_unittest_pb2.py
Electrum-3.1.3/packages/google/protobuf/test_messages_proto3_pb2.py
Electrum-3.1.3/packages/google/protobuf/unittest_import_public_pb2.py
Electrum-3.1.3/packages/google/protobuf/timestamp_pb2.py
Electrum-3.1.3/packages/google/protobuf/service_reflection.py
Electrum-3.1.3/packages/google/protobuf/message_factory.py
Electrum-3.1.3/packages/google/protobuf/compiler/
Electrum-3.1.3/packages/google/protobuf/compiler/__init__.py
Electrum-3.1.3/packages/google/protobuf/compiler/plugin_pb2.py
Electrum-3.1.3/packages/google/protobuf/field_mask_pb2.py
Electrum-3.1.3/packages/google/protobuf/duration_pb2.py
Electrum-3.1.3/RELEASE-NOTES
Electrum-3.1.3/electrum.conf.sample
Electrum-3.1.3/PKG-INFO
Electrum-3.1.3/README.rst
Electrum-3.1.3/plugins/
Electrum-3.1.3/plugins/trezor/
Electrum-3.1.3/plugins/trezor/__init__.py
Electrum-3.1.3/plugins/trezor/client.py
Electrum-3.1.3/plugins/trezor/clientbase.py
Electrum-3.1.3/plugins/trezor/transport.py
Electrum-3.1.3/plugins/trezor/cmdline.py
Electrum-3.1.3/plugins/trezor/qt_generic.py
Electrum-3.1.3/plugins/trezor/trezor.py
Electrum-3.1.3/plugins/trezor/qt.py
Electrum-3.1.3/plugins/__init__.py
Electrum-3.1.3/plugins/digitalbitbox/
Electrum-3.1.3/plugins/digitalbitbox/__init__.py
Electrum-3.1.3/plugins/digitalbitbox/cmdline.py
Electrum-3.1.3/plugins/digitalbitbox/digitalbitbox.py
Electrum-3.1.3/plugins/digitalbitbox/qt.py
Electrum-3.1.3/plugins/email_requests/
Electrum-3.1.3/plugins/email_requests/__init__.py
Electrum-3.1.3/plugins/email_requests/qt.py
Electrum-3.1.3/plugins/ledger/
Electrum-3.1.3/plugins/ledger/__init__.py
Electrum-3.1.3/plugins/ledger/cmdline.py
Electrum-3.1.3/plugins/ledger/ledger.py
Electrum-3.1.3/plugins/ledger/auth2fa.py
Electrum-3.1.3/plugins/ledger/qt.py
Electrum-3.1.3/plugins/audio_modem/
Electrum-3.1.3/plugins/audio_modem/__init__.py
Electrum-3.1.3/plugins/audio_modem/qt.py
Electrum-3.1.3/plugins/labels/
Electrum-3.1.3/plugins/labels/__init__.py
Electrum-3.1.3/plugins/labels/kivy.py
Electrum-3.1.3/plugins/labels/qt.py
Electrum-3.1.3/plugins/labels/labels.py
Electrum-3.1.3/plugins/keepkey/
Electrum-3.1.3/plugins/keepkey/__init__.py
Electrum-3.1.3/plugins/keepkey/client.py
Electrum-3.1.3/plugins/keepkey/clientbase.py
Electrum-3.1.3/plugins/keepkey/keepkey.py
Electrum-3.1.3/plugins/keepkey/plugin.py
Electrum-3.1.3/plugins/keepkey/cmdline.py
Electrum-3.1.3/plugins/keepkey/qt_generic.py
Electrum-3.1.3/plugins/keepkey/qt.py
Electrum-3.1.3/plugins/virtualkeyboard/
Electrum-3.1.3/plugins/virtualkeyboard/__init__.py
Electrum-3.1.3/plugins/virtualkeyboard/qt.py
Electrum-3.1.3/plugins/trustedcoin/
Electrum-3.1.3/plugins/trustedcoin/__init__.py
Electrum-3.1.3/plugins/trustedcoin/cmdline.py
Electrum-3.1.3/plugins/trustedcoin/trustedcoin.py
Electrum-3.1.3/plugins/trustedcoin/qt.py
Electrum-3.1.3/plugins/hw_wallet/
Electrum-3.1.3/plugins/hw_wallet/__init__.py
Electrum-3.1.3/plugins/hw_wallet/plugin.py
Electrum-3.1.3/plugins/hw_wallet/cmdline.py
Electrum-3.1.3/plugins/hw_wallet/qt.py
Electrum-3.1.3/plugins/greenaddress_instant/
Electrum-3.1.3/plugins/greenaddress_instant/__init__.py
Electrum-3.1.3/plugins/greenaddress_instant/qt.py
Electrum-3.1.3/plugins/cosigner_pool/
Electrum-3.1.3/plugins/cosigner_pool/__init__.py
Electrum-3.1.3/plugins/cosigner_pool/qt.py
Electrum-3.1.3/LICENCE
Electrum-3.1.3/Electrum.egg-info/
Electrum-3.1.3/Electrum.egg-info/top_level.txt
Electrum-3.1.3/Electrum.egg-info/requires.txt
Electrum-3.1.3/Electrum.egg-info/PKG-INFO
Electrum-3.1.3/Electrum.egg-info/dependency_links.txt
Electrum-3.1.3/Electrum.egg-info/SOURCES.txt
Electrum-3.1.3/gui/
Electrum-3.1.3/gui/__init__.py
Electrum-3.1.3/gui/text.py
Electrum-3.1.3/gui/stdio.py
Electrum-3.1.3/gui/qt/
Electrum-3.1.3/gui/qt/history_list.py
Electrum-3.1.3/gui/qt/address_dialog.py
Electrum-3.1.3/gui/qt/__init__.py
Electrum-3.1.3/gui/qt/seed_dialog.py
Electrum-3.1.3/gui/qt/password_dialog.py
Electrum-3.1.3/gui/qt/qrtextedit.py
Electrum-3.1.3/gui/qt/util.py
Electrum-3.1.3/gui/qt/installwizard.py
Electrum-3.1.3/gui/qt/network_dialog.py
Electrum-3.1.3/gui/qt/icons_rc.py
Electrum-3.1.3/gui/qt/utxo_list.py
Electrum-3.1.3/gui/qt/paytoedit.py
Electrum-3.1.3/gui/qt/invoice_list.py
Electrum-3.1.3/gui/qt/contact_list.py
Electrum-3.1.3/gui/qt/amountedit.py
Electrum-3.1.3/gui/qt/exception_window.py
Electrum-3.1.3/gui/qt/request_list.py
Electrum-3.1.3/gui/qt/completion_text_edit.py
Electrum-3.1.3/gui/qt/fee_slider.py
Electrum-3.1.3/gui/qt/address_list.py
Electrum-3.1.3/gui/qt/main_window.py
Electrum-3.1.3/gui/qt/qrwindow.py
Electrum-3.1.3/gui/qt/qrcodewidget.py
Electrum-3.1.3/gui/qt/transaction_dialog.py
Electrum-3.1.3/gui/qt/console.py
Electrum-3.1.3/gui/kivy/
Electrum-3.1.3/gui/kivy/__init__.py
Electrum-3.1.3/gui/kivy/uix/
Electrum-3.1.3/gui/kivy/uix/drawer.py
Electrum-3.1.3/gui/kivy/uix/__init__.py
Electrum-3.1.3/gui/kivy/uix/gridview.py
Electrum-3.1.3/gui/kivy/uix/combobox.py
Electrum-3.1.3/gui/kivy/uix/context_menu.py
Electrum-3.1.3/gui/kivy/uix/menus.py
Electrum-3.1.3/gui/kivy/uix/screens.py
Electrum-3.1.3/gui/kivy/uix/dialogs/
Electrum-3.1.3/gui/kivy/uix/dialogs/__init__.py
Electrum-3.1.3/gui/kivy/uix/dialogs/wallets.py
Electrum-3.1.3/gui/kivy/uix/dialogs/password_dialog.py
Electrum-3.1.3/gui/kivy/uix/dialogs/installwizard.py
Electrum-3.1.3/gui/kivy/uix/dialogs/label_dialog.py
Electrum-3.1.3/gui/kivy/uix/dialogs/settings.py
Electrum-3.1.3/gui/kivy/uix/dialogs/tx_dialog.py
Electrum-3.1.3/gui/kivy/uix/dialogs/qr_scanner.py
Electrum-3.1.3/gui/kivy/uix/dialogs/fee_dialog.py
Electrum-3.1.3/gui/kivy/uix/dialogs/nfc_transaction.py
Electrum-3.1.3/gui/kivy/uix/dialogs/question.py
Electrum-3.1.3/gui/kivy/uix/dialogs/addresses.py
Electrum-3.1.3/gui/kivy/uix/dialogs/seed_options.py
Electrum-3.1.3/gui/kivy/uix/dialogs/qr_dialog.py
Electrum-3.1.3/gui/kivy/uix/dialogs/choice_dialog.py
Electrum-3.1.3/gui/kivy/uix/dialogs/requests.py
Electrum-3.1.3/gui/kivy/uix/dialogs/amount_dialog.py
Electrum-3.1.3/gui/kivy/uix/dialogs/bump_fee_dialog.py
Electrum-3.1.3/gui/kivy/uix/dialogs/invoices.py
Electrum-3.1.3/gui/kivy/uix/dialogs/fx_dialog.py
Electrum-3.1.3/gui/kivy/uix/dialogs/checkbox_dialog.py
Electrum-3.1.3/gui/kivy/uix/qrcodewidget.py
Electrum-3.1.3/gui/kivy/i18n.py
Electrum-3.1.3/gui/kivy/nfc_scanner/
Electrum-3.1.3/gui/kivy/nfc_scanner/__init__.py
Electrum-3.1.3/gui/kivy/nfc_scanner/scanner_dummy.py
Electrum-3.1.3/gui/kivy/nfc_scanner/scanner_android.py
Electrum-3.1.3/gui/kivy/main_window.py
Electrum-3.1.3/lib/
Electrum-3.1.3/lib/__init__.py
Electrum-3.1.3/lib/commands.py
Electrum-3.1.3/lib/ln/
Electrum-3.1.3/lib/ln/__init__.py
Electrum-3.1.3/lib/plot.py
Electrum-3.1.3/lib/old_mnemonic.py
Electrum-3.1.3/lib/daemon.py
Electrum-3.1.3/lib/util.py
Electrum-3.1.3/lib/verifier.py
Electrum-3.1.3/lib/base_wizard.py
Electrum-3.1.3/lib/dnssec.py
Electrum-3.1.3/lib/contacts.py
Electrum-3.1.3/lib/keystore.py
Electrum-3.1.3/lib/wallet.py
Electrum-3.1.3/lib/mnemonic.py
Electrum-3.1.3/lib/wordlist/
Electrum-3.1.3/lib/wordlist/japanese.txt
Electrum-3.1.3/lib/wordlist/spanish.txt
Electrum-3.1.3/lib/wordlist/portuguese.txt
Electrum-3.1.3/lib/wordlist/english.txt
Electrum-3.1.3/lib/wordlist/chinese_simplified.txt
Electrum-3.1.3/lib/storage.py
Electrum-3.1.3/lib/pem.py
Electrum-3.1.3/lib/blockchain.py
Electrum-3.1.3/lib/i18n.py
Electrum-3.1.3/lib/websockets.py
Electrum-3.1.3/lib/msqr.py
Electrum-3.1.3/lib/paymentrequest_pb2.py
Electrum-3.1.3/lib/currencies.json
Electrum-3.1.3/lib/exchange_rate.py
Electrum-3.1.3/lib/constants.py
Electrum-3.1.3/lib/rsakey.py
Electrum-3.1.3/lib/servers_regtest.json
Electrum-3.1.3/lib/interface.py
Electrum-3.1.3/lib/bitcoin.py
Electrum-3.1.3/lib/x509.py
Electrum-3.1.3/lib/synchronizer.py
Electrum-3.1.3/lib/locale/
Electrum-3.1.3/lib/locale/nl_NL/
Electrum-3.1.3/lib/locale/nl_NL/LC_MESSAGES/
Electrum-3.1.3/lib/locale/nl_NL/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/zh_TW/
Electrum-3.1.3/lib/locale/zh_TW/LC_MESSAGES/
Electrum-3.1.3/lib/locale/zh_TW/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/ta_IN/
Electrum-3.1.3/lib/locale/ta_IN/LC_MESSAGES/
Electrum-3.1.3/lib/locale/ta_IN/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/th_TH/
Electrum-3.1.3/lib/locale/th_TH/LC_MESSAGES/
Electrum-3.1.3/lib/locale/th_TH/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/da_DK/
Electrum-3.1.3/lib/locale/da_DK/LC_MESSAGES/
Electrum-3.1.3/lib/locale/da_DK/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/ja_JP/
Electrum-3.1.3/lib/locale/ja_JP/LC_MESSAGES/
Electrum-3.1.3/lib/locale/ja_JP/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/ko_KR/
Electrum-3.1.3/lib/locale/ko_KR/LC_MESSAGES/
Electrum-3.1.3/lib/locale/ko_KR/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/nb_NO/
Electrum-3.1.3/lib/locale/nb_NO/LC_MESSAGES/
Electrum-3.1.3/lib/locale/nb_NO/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/es_ES/
Electrum-3.1.3/lib/locale/es_ES/LC_MESSAGES/
Electrum-3.1.3/lib/locale/es_ES/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/pt_BR/
Electrum-3.1.3/lib/locale/pt_BR/LC_MESSAGES/
Electrum-3.1.3/lib/locale/pt_BR/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/de_DE/
Electrum-3.1.3/lib/locale/de_DE/LC_MESSAGES/
Electrum-3.1.3/lib/locale/de_DE/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/cs_CZ/
Electrum-3.1.3/lib/locale/cs_CZ/LC_MESSAGES/
Electrum-3.1.3/lib/locale/cs_CZ/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/eo_UY/
Electrum-3.1.3/lib/locale/eo_UY/LC_MESSAGES/
Electrum-3.1.3/lib/locale/eo_UY/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/id_ID/
Electrum-3.1.3/lib/locale/id_ID/LC_MESSAGES/
Electrum-3.1.3/lib/locale/id_ID/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/pl_PL/
Electrum-3.1.3/lib/locale/pl_PL/LC_MESSAGES/
Electrum-3.1.3/lib/locale/pl_PL/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/ar_SA/
Electrum-3.1.3/lib/locale/ar_SA/LC_MESSAGES/
Electrum-3.1.3/lib/locale/ar_SA/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/hu_HU/
Electrum-3.1.3/lib/locale/hu_HU/LC_MESSAGES/
Electrum-3.1.3/lib/locale/hu_HU/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/tr_TR/
Electrum-3.1.3/lib/locale/tr_TR/LC_MESSAGES/
Electrum-3.1.3/lib/locale/tr_TR/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/uk_UA/
Electrum-3.1.3/lib/locale/uk_UA/LC_MESSAGES/
Electrum-3.1.3/lib/locale/uk_UA/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/vi_VN/
Electrum-3.1.3/lib/locale/vi_VN/LC_MESSAGES/
Electrum-3.1.3/lib/locale/vi_VN/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/ky_KG/
Electrum-3.1.3/lib/locale/ky_KG/LC_MESSAGES/
Electrum-3.1.3/lib/locale/ky_KG/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/it_IT/
Electrum-3.1.3/lib/locale/it_IT/LC_MESSAGES/
Electrum-3.1.3/lib/locale/it_IT/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/el_GR/
Electrum-3.1.3/lib/locale/el_GR/LC_MESSAGES/
Electrum-3.1.3/lib/locale/el_GR/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/hy_AM/
Electrum-3.1.3/lib/locale/hy_AM/LC_MESSAGES/
Electrum-3.1.3/lib/locale/hy_AM/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/sl_SI/
Electrum-3.1.3/lib/locale/sl_SI/LC_MESSAGES/
Electrum-3.1.3/lib/locale/sl_SI/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/fr_FR/
Electrum-3.1.3/lib/locale/fr_FR/LC_MESSAGES/
Electrum-3.1.3/lib/locale/fr_FR/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/pt_PT/
Electrum-3.1.3/lib/locale/pt_PT/LC_MESSAGES/
Electrum-3.1.3/lib/locale/pt_PT/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/fa_IR/
Electrum-3.1.3/lib/locale/fa_IR/LC_MESSAGES/
Electrum-3.1.3/lib/locale/fa_IR/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/ru_RU/
Electrum-3.1.3/lib/locale/ru_RU/LC_MESSAGES/
Electrum-3.1.3/lib/locale/ru_RU/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/zh_CN/
Electrum-3.1.3/lib/locale/zh_CN/LC_MESSAGES/
Electrum-3.1.3/lib/locale/zh_CN/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/ro_RO/
Electrum-3.1.3/lib/locale/ro_RO/LC_MESSAGES/
Electrum-3.1.3/lib/locale/ro_RO/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/lv_LV/
Electrum-3.1.3/lib/locale/lv_LV/LC_MESSAGES/
Electrum-3.1.3/lib/locale/lv_LV/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/bg_BG/
Electrum-3.1.3/lib/locale/bg_BG/LC_MESSAGES/
Electrum-3.1.3/lib/locale/bg_BG/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/sk_SK/
Electrum-3.1.3/lib/locale/sk_SK/LC_MESSAGES/
Electrum-3.1.3/lib/locale/sk_SK/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/locale/sv_SE/
Electrum-3.1.3/lib/locale/sv_SE/LC_MESSAGES/
Electrum-3.1.3/lib/locale/sv_SE/LC_MESSAGES/electrum.mo
Electrum-3.1.3/lib/qrscanner.py
Electrum-3.1.3/lib/jsonrpc.py
Electrum-3.1.3/lib/transaction.py
Electrum-3.1.3/lib/paymentrequest.py
Electrum-3.1.3/lib/fee_estimator.py
Electrum-3.1.3/lib/servers.json
Electrum-3.1.3/lib/servers_testnet.json
Electrum-3.1.3/lib/coinchooser.py
Electrum-3.1.3/lib/plugins.py
Electrum-3.1.3/lib/network.py
Electrum-3.1.3/lib/checkpoints.json
Electrum-3.1.3/lib/ripemd.py
Electrum-3.1.3/lib/checkpoints_testnet.json
Electrum-3.1.3/lib/simple_config.py
Electrum-3.1.3/lib/tests/
Electrum-3.1.3/lib/tests/__init__.py
Electrum-3.1.3/lib/tests/test_storage_upgrade.py
Electrum-3.1.3/lib/tests/test_wallet_vertical.py
Electrum-3.1.3/lib/tests/test_transaction.py
Electrum-3.1.3/lib/tests/test_interface.py
Electrum-3.1.3/lib/tests/test_bitcoin.py
Electrum-3.1.3/lib/tests/test_util.py
Electrum-3.1.3/lib/tests/test_wallet.py
Electrum-3.1.3/lib/tests/test_commands.py
Electrum-3.1.3/lib/tests/test_simple_config.py
Electrum-3.1.3/lib/tests/test_mnemonic.py
Electrum-3.1.3/lib/segwit_addr.py
Electrum-3.1.3/lib/version.py
Electrum-3.1.3/icons.qrc
Electrum-3.1.3/setup.py
Electrum-3.1.3/scripts/
Electrum-3.1.3/scripts/util.py
Electrum-3.1.3/scripts/get_history
Electrum-3.1.3/scripts/txradar
Electrum-3.1.3/scripts/estimate_fee
Electrum-3.1.3/scripts/block_headers
Electrum-3.1.3/scripts/peers
Electrum-3.1.3/scripts/bip70
Electrum-3.1.3/scripts/util.pyc
Electrum-3.1.3/scripts/servers
Electrum-3.1.3/scripts/watch_address
Electrum-3.1.3/scripts/__pycache__/
Electrum-3.1.3/scripts/__pycache__/lntest.cpython-36.pyc
Electrum-3.1.3/scripts/__pycache__/util.cpython-35.pyc
Electrum-3.1.3/AUTHORS
Electrum-3.1.3/electrum.desktop
Electrum-3.1.3/setup.cfg

root@test1:/home/work# python --version

Python 2.7.13

root@test1:/home/work# python3 --version

Python 3.5.3

Ok. Python 3 is available.

Next:
- In the electrum directory, run: 'python3 electrum'

Hm.

root@test1:/home/work# ls -1

Electrum-3.1.3
Electrum-3.1.3.tar.gz
Electrum-3.1.3.tar.gz.asc
thomasv.public_key

I think "the electrum directory" is Electrum-3.1.3.

root@test1:/home/work# cd Electrum-3.1.3

root@test1:/home/work/Electrum-3.1.3# python3 electrum

Error: Could not import PyQt5 on Linux systems, you may try 'sudo apt-get install python3-pyqt5'

Excerpt from:
electrum.org/#download

Easy installation

Linux:

Install dependencies:

sudo apt-get install python3-setuptools python3-pyqt5 python3-pip

Install Electrum:

sudo pip3 install https://download.electrum.org/3.1.3/Electrum-3.1.3.tar.gz

I'm running as

root

, so I won't need to use

sudo

root@test1:/home/work/Electrum-3.1.3# apt-get --version

apt 1.4.8 (amd64) Supported modules: *Ver: Standard .deb *Pkg: Debian dpkg interface (Priority 30) Pkg: Debian APT solver interface (Priority -1000) Pkg: Debian APT planner interface (Priority -1000) S.L: 'deb' Debian binary tree S.L: 'deb-src' Debian source tree Idx: Debian Source Index Idx: Debian Package Index Idx: Debian Translation Index Idx: Debian dpkg status file Idx: Debian deb file Idx: Debian dsc file Idx: Debian control file Idx: EDSP scenario file Idx: EIPP scenario file

root@test1:/home/work/Electrum-3.1.3# apt-get python3-setuptools python3-pyqt5 python3-pip

Reading package lists... Done
Building dependency tree
Reading state information... Done
E: Unable to locate package python3-pyqt5
E: Unable to locate package python3-pip

Google "E: Unable to locate package python3-pyqt5"

Excerpt from first result:
stackoverflow.com/questions/47583526/cant-install-python3-pyqt5-on-ubuntu-17

Q:

Cant install python3-pyqt5 on ubuntu 17

I`m trying to install python3-pyqt5, but still getting the same error. I tried reinstalling ubuntu, updating and upgrading my apt-get and still no clue whats wrong.

ubuntu@ubuntu:~$ sudo apt-get install python3-pyqt5
Reading package lists... Done
Building dependency tree
Reading state information... Done
E: Unable to locate package python3-pyqt5

asked Nov 30 '17 at 22:14
user2279379

A:

I had the same problem. After doing some reading, I was able to install pyqt5 using this workaround:

1. Install python3-setuptools:

$ sudo apt-get install python3-setuptools

2. Install pip:

$ sudo easy_install3 pip

3. Finally, install pyqt5 using pip:

$ pip3 install --user pyqt5

edited Dec 3 '17 at 19:46
answered Dec 3 '17 at 19:40
liorr

root@test1:/home/work/Electrum-3.1.3# apt-get install python3-setuptools

Reading package lists... Done
Building dependency tree
Reading state information... Done
python3-setuptools is already the newest version (33.1.1-1).
0 upgraded, 0 newly installed, 0 to remove and 0 not upgraded.

root@test1:/home/work/Electrum-3.1.3# easy_install3 pip

Searching for pip
Reading https://pypi.python.org/simple/pip/
Downloading https://files.pythonhosted.org/packages/ae/e8/2340d46ecadb1692a1e455f13f75e596d4eab3d11a57446f08259dee8f02/pip-10.0.1.tar.gz#sha256=f2bd08e0cd1b06e10218feaf6fef299f473ba706582eb3bd9d52203fdbd7ee68
Best match: pip 10.0.1
Processing pip-10.0.1.tar.gz
Writing /tmp/easy_install-4xe_3ula/pip-10.0.1/setup.cfg
Running pip-10.0.1/setup.py -q bdist_egg --dist-dir /tmp/easy_install-4xe_3ula/pip-10.0.1/egg-dist-tmp-w0a7skct
warning: no previously-included files found matching '.coveragerc'
warning: no previously-included files found matching '.mailmap'
warning: no previously-included files found matching '.travis.yml'
warning: no previously-included files found matching '.landscape.yml'
warning: no previously-included files found matching 'src/pip/_vendor/Makefile'
warning: no previously-included files found matching 'tox.ini'
warning: no previously-included files found matching '*-requirements.txt'
warning: no previously-included files found matching 'appveyor.yml'
warning: no previously-included files found matching 'src/pip/_vendor/six'
warning: no previously-included files matching '*.pyi' found under directory 'src/pip/_vendor'
no previously-included directories found matching '.github'
no previously-included directories found matching '.travis'
no previously-included directories found matching 'docs/build'
no previously-included directories found matching 'news'
no previously-included directories found matching 'contrib'
no previously-included directories found matching 'tasks'
no previously-included directories found matching 'tests'
creating /usr/local/lib/python3.5/dist-packages/pip-10.0.1-py3.5.egg
Extracting pip-10.0.1-py3.5.egg to /usr/local/lib/python3.5/dist-packages
Adding pip 10.0.1 to easy-install.pth file
Installing pip3 script to /usr/local/bin
Installing pip script to /usr/local/bin
Installing pip3.5 script to /usr/local/bin

Installed /usr/local/lib/python3.5/dist-packages/pip-10.0.1-py3.5.egg
Processing dependencies for pip
Finished processing dependencies for pip

root@test1:/home/work/Electrum-3.1.3# pip3 install --user pyqt5

Collecting pyqt5 Downloading https://files.pythonhosted.org/packages/e4/15/4e2e49f64884edbab6f833c6fd3add24d7938f2429aec1f2883e645d4d8f/PyQt5-5.10.1-5.10.1-cp35.cp36.cp37.cp38-abi3-manylinux1_x86_64.whl (107.8MB) [many progress update lines with non-ASCII bytes omitted] Collecting sip<4.20,>=4.19.4 (from pyqt5) Downloading https://files.pythonhosted.org/packages/6b/46/2869369c8ec634ec9dc714b84834e9264acbe87eb7492328efccfa0c855e/sip-4.19.8-cp35-cp35m-manylinux1_x86_64.whl (66kB) [many progress update lines with non-ASCII bytes omitted] Installing collected packages: sip, pyqt5 The scripts pylupdate5, pyrcc5 and pyuic5 are installed in '/root/.local/bin' which is not on PATH. Consider adding this directory to PATH or, if you prefer to suppress this warning, use --no-warn-script-location. Successfully installed pyqt5-5.10.1 sip-4.19.8

Note the use of:
[many progress update lines with non-ASCII bytes omitted]
This was not part of the original output.

root@test1:/home/work/Electrum-3.1.3# python3 electrum

Traceback (most recent call last): File "electrum", line 418, in <module> d.init_gui(config, plugins) File "/home/work/Electrum-3.1.3/lib/daemon.py", line 308, in init_gui gui = __import__('electrum_gui.' + gui_name, fromlist=['electrum_gui']) File "/home/work/Electrum-3.1.3/gui/qt/__init__.py", line 36, in <module> from PyQt5.QtGui import * ImportError: libGL.so.1: cannot open shared object file: No such file or directory

libGL.so.1 looks like a shared library file.

Browse to:
pkgs.org

Click the search bar. Choose distribution = Debian 9 (Stretch). Enter "libGL.so.1" and click Search.

No results for Debian 9.

There are various results.

Under ALT Linux Sisyphus, there is this one:
- Classic i586:
-- libGL-18.1.0-alt1.S1.i586.rpm
--- OpenGL 1.3 compatible 3D graphics library for X Window server

Under Centos 7, there is this one:
- CentOS x86_64
-- mesa-libGL-17.2.3-8.20171019.el7.i686.rpm
--- Mesa libGL runtime libraries and DRI drivers

Browse to packages.debian.org. Search for libGL.so.1.

7 results:

File [Packages]
/usr/lib/i386-linux-gnu/libGL.so.1 [libgl1-mesa-glx]
/usr/lib/i386-linux-gnu/libGL.so.1.2.0 [libgl1-mesa-glx]
/usr/lib/i386-linux-gnu/nvidia/current/libGL.so.1 [libgl1-glvnd-nvidia-glx, libgl1-nvidia-glx]
/usr/lib/i386-linux-gnu/nvidia/current/libGL.so.1.0.0 [libgl1-glvnd-nvidia-glx]
/usr/lib/i386-linux-gnu/nvidia/legacy-304xx/libGL.so.1 [libgl1-nvidia-legacy-304xx-glx]
/usr/lib/i386-linux-gnu/nvidia/legacy-340xx/libGL.so.1 [libgl1-nvidia-legacy-340xx-glx]
/usr/lib/i386-linux-gnu/primus/libGL.so.1 [primus-libs]

I'll look for the first package: libgl1-mesa-glx

root@test1:/home/work/Electrum-3.1.3# apt-cache search libgl1-mesa-glx

root@test1:/home/work/Electrum-3.1.3# apt-get update

[output omitted]

root@test1:/home/work/Electrum-3.1.3# apt-cache search libgl1-mesa-glx

libgl1-mesa-dev - free implementation of the OpenGL API -- GLX development files
libgl1-mesa-dri - free implementation of the OpenGL API -- DRI modules
libgl1-mesa-glx - free implementation of the OpenGL API -- GLX runtime
glx-alternative-mesa - allows the selection of MESA as GLX provider

root@test1:/home/work/Electrum-3.1.3# apt-get install libgl1-mesa-glx

Reading package lists... Done Building dependency tree Reading state information... Done The following additional packages will be installed: libdrm-amdgpu1 libdrm-intel1 libdrm-nouveau2 libdrm-radeon1 libdrm2 libgl1-mesa-dri libglapi-mesa libllvm3.9 libpciaccess0 libsensors4 libtxc-dxtn-s2tc libx11-6 libx11-data libx11-xcb1 libxau6 libxcb-dri2-0 libxcb-dri3-0 libxcb-glx0 libxcb-present0 libxcb-sync1 libxcb1 libxdamage1 libxdmcp6 libxext6 libxfixes3 libxshmfence1 libxxf86vm1 Suggested packages: pciutils lm-sensors The following NEW packages will be installed: libdrm-amdgpu1 libdrm-intel1 libdrm-nouveau2 libdrm-radeon1 libdrm2 libgl1-mesa-dri libgl1-mesa-glx libglapi-mesa libllvm3.9 libpciaccess0 libsensors4 libtxc-dxtn-s2tc libx11-6 libx11-data libx11-xcb1 libxau6 libxcb-dri2-0 libxcb-dri3-0 libxcb-glx0 libxcb-present0 libxcb-sync1 libxcb1 libxdamage1 libxdmcp6 libxext6 libxfixes3 libxshmfence1 libxxf86vm1 0 upgraded, 28 newly installed, 0 to remove and 3 not upgraded. Need to get 18.4 MB of archives. After this operation, 169 MB of additional disk space will be used. Do you want to continue? [Y/n] y Get:1 http://mirrors.digitalocean.com/debian stretch/main amd64 libxau6 amd64 1:1.0.8-1 [20.7 kB] Get:2 http://mirrors.digitalocean.com/debian stretch/main amd64 libdrm2 amd64 2.4.74-1 [36.2 kB] Get:3 http://mirrors.digitalocean.com/debian stretch/main amd64 libdrm-amdgpu1 amd64 2.4.74-1 [26.4 kB] Get:4 http://mirrors.digitalocean.com/debian stretch/main amd64 libpciaccess0 amd64 0.13.4-1+b2 [50.0 kB] Get:5 http://mirrors.digitalocean.com/debian stretch/main amd64 libdrm-intel1 amd64 2.4.74-1 [68.7 kB] Get:6 http://mirrors.digitalocean.com/debian stretch/main amd64 libdrm-nouveau2 amd64 2.4.74-1 [25.1 kB] Get:7 http://mirrors.digitalocean.com/debian stretch/main amd64 libdrm-radeon1 amd64 2.4.74-1 [30.2 kB] Get:8 http://mirrors.digitalocean.com/debian stretch/main amd64 libllvm3.9 amd64 1:3.9.1-9 [11.3 MB] Get:9 http://mirrors.digitalocean.com/debian stretch/main amd64 libsensors4 amd64 1:3.4.0-4 [53.3 kB] Get:10 http://mirrors.digitalocean.com/debian stretch/main amd64 libgl1-mesa-dri amd64 13.0.6-1+b2 [4,536 kB] Get:11 http://mirrors.digitalocean.com/debian stretch/main amd64 libglapi-mesa amd64 13.0.6-1+b2 [58.9 kB] Get:12 http://mirrors.digitalocean.com/debian stretch/main amd64 libxdmcp6 amd64 1:1.1.2-3 [26.3 kB] Get:13 http://mirrors.digitalocean.com/debian stretch/main amd64 libxcb1 amd64 1.12-1 [133 kB] Get:14 http://mirrors.digitalocean.com/debian stretch/main amd64 libx11-data all 2:1.6.4-3 [290 kB] Get:15 http://mirrors.digitalocean.com/debian stretch/main amd64 libx11-6 amd64 2:1.6.4-3 [747 kB] Get:16 http://mirrors.digitalocean.com/debian stretch/main amd64 libx11-xcb1 amd64 2:1.6.4-3 [183 kB] Get:17 http://mirrors.digitalocean.com/debian stretch/main amd64 libxcb-dri2-0 amd64 1.12-1 [97.2 kB] Get:18 http://mirrors.digitalocean.com/debian stretch/main amd64 libxcb-dri3-0 amd64 1.12-1 [95.6 kB] Get:19 http://mirrors.digitalocean.com/debian stretch/main amd64 libxcb-glx0 amd64 1.12-1 [113 kB] Get:20 http://mirrors.digitalocean.com/debian stretch/main amd64 libxcb-present0 amd64 1.12-1 [95.8 kB] Get:21 http://mirrors.digitalocean.com/debian stretch/main amd64 libxcb-sync1 amd64 1.12-1 [99.2 kB] Get:22 http://mirrors.digitalocean.com/debian stretch/main amd64 libxfixes3 amd64 1:5.0.3-1 [21.9 kB] Get:23 http://mirrors.digitalocean.com/debian stretch/main amd64 libxdamage1 amd64 1:1.1.4-2+b3 [14.5 kB] Get:24 http://mirrors.digitalocean.com/debian stretch/main amd64 libxext6 amd64 2:1.3.3-1+b2 [52.5 kB] Get:25 http://mirrors.digitalocean.com/debian stretch/main amd64 libxshmfence1 amd64 1.2-1+b2 [7,922 B] Get:26 http://mirrors.digitalocean.com/debian stretch/main amd64 libxxf86vm1 amd64 1:1.1.4-1+b2 [20.8 kB] Get:27 http://mirrors.digitalocean.com/debian stretch/main amd64 libgl1-mesa-glx amd64 13.0.6-1+b2 [167 kB] Get:28 http://mirrors.digitalocean.com/debian stretch/main amd64 libtxc-dxtn-s2tc amd64 1.0+git20151227-2 [48.4 kB] Fetched 18.4 MB in 1s (11.1 MB/s) Selecting previously unselected package libxau6:amd64. (Reading database ... 29429 files and directories currently installed.) Preparing to unpack .../00-libxau6_1%3a1.0.8-1_amd64.deb ... Unpacking libxau6:amd64 (1:1.0.8-1) ... Selecting previously unselected package libdrm2:amd64. Preparing to unpack .../01-libdrm2_2.4.74-1_amd64.deb ... Unpacking libdrm2:amd64 (2.4.74-1) ... Selecting previously unselected package libdrm-amdgpu1:amd64. Preparing to unpack .../02-libdrm-amdgpu1_2.4.74-1_amd64.deb ... Unpacking libdrm-amdgpu1:amd64 (2.4.74-1) ... Selecting previously unselected package libpciaccess0:amd64. Preparing to unpack .../03-libpciaccess0_0.13.4-1+b2_amd64.deb ... Unpacking libpciaccess0:amd64 (0.13.4-1+b2) ... Selecting previously unselected package libdrm-intel1:amd64. Preparing to unpack .../04-libdrm-intel1_2.4.74-1_amd64.deb ... Unpacking libdrm-intel1:amd64 (2.4.74-1) ... Selecting previously unselected package libdrm-nouveau2:amd64. Preparing to unpack .../05-libdrm-nouveau2_2.4.74-1_amd64.deb ... Unpacking libdrm-nouveau2:amd64 (2.4.74-1) ... Selecting previously unselected package libdrm-radeon1:amd64. Preparing to unpack .../06-libdrm-radeon1_2.4.74-1_amd64.deb ... Unpacking libdrm-radeon1:amd64 (2.4.74-1) ... Selecting previously unselected package libllvm3.9:amd64. Preparing to unpack .../07-libllvm3.9_1%3a3.9.1-9_amd64.deb ... Unpacking libllvm3.9:amd64 (1:3.9.1-9) ... Selecting previously unselected package libsensors4:amd64. Preparing to unpack .../08-libsensors4_1%3a3.4.0-4_amd64.deb ... Unpacking libsensors4:amd64 (1:3.4.0-4) ... Selecting previously unselected package libgl1-mesa-dri:amd64. Preparing to unpack .../09-libgl1-mesa-dri_13.0.6-1+b2_amd64.deb ... Unpacking libgl1-mesa-dri:amd64 (13.0.6-1+b2) ... Selecting previously unselected package libglapi-mesa:amd64. Preparing to unpack .../10-libglapi-mesa_13.0.6-1+b2_amd64.deb ... Unpacking libglapi-mesa:amd64 (13.0.6-1+b2) ... Selecting previously unselected package libxdmcp6:amd64. Preparing to unpack .../11-libxdmcp6_1%3a1.1.2-3_amd64.deb ... Unpacking libxdmcp6:amd64 (1:1.1.2-3) ... Selecting previously unselected package libxcb1:amd64. Preparing to unpack .../12-libxcb1_1.12-1_amd64.deb ... Unpacking libxcb1:amd64 (1.12-1) ... Selecting previously unselected package libx11-data. Preparing to unpack .../13-libx11-data_2%3a1.6.4-3_all.deb ... Unpacking libx11-data (2:1.6.4-3) ... Selecting previously unselected package libx11-6:amd64. Preparing to unpack .../14-libx11-6_2%3a1.6.4-3_amd64.deb ... Unpacking libx11-6:amd64 (2:1.6.4-3) ... Selecting previously unselected package libx11-xcb1:amd64. Preparing to unpack .../15-libx11-xcb1_2%3a1.6.4-3_amd64.deb ... Unpacking libx11-xcb1:amd64 (2:1.6.4-3) ... Selecting previously unselected package libxcb-dri2-0:amd64. Preparing to unpack .../16-libxcb-dri2-0_1.12-1_amd64.deb ... Unpacking libxcb-dri2-0:amd64 (1.12-1) ... Selecting previously unselected package libxcb-dri3-0:amd64. Preparing to unpack .../17-libxcb-dri3-0_1.12-1_amd64.deb ... Unpacking libxcb-dri3-0:amd64 (1.12-1) ... Selecting previously unselected package libxcb-glx0:amd64. Preparing to unpack .../18-libxcb-glx0_1.12-1_amd64.deb ... Unpacking libxcb-glx0:amd64 (1.12-1) ... Selecting previously unselected package libxcb-present0:amd64. Preparing to unpack .../19-libxcb-present0_1.12-1_amd64.deb ... Unpacking libxcb-present0:amd64 (1.12-1) ... Selecting previously unselected package libxcb-sync1:amd64. Preparing to unpack .../20-libxcb-sync1_1.12-1_amd64.deb ... Unpacking libxcb-sync1:amd64 (1.12-1) ... Selecting previously unselected package libxfixes3:amd64. Preparing to unpack .../21-libxfixes3_1%3a5.0.3-1_amd64.deb ... Unpacking libxfixes3:amd64 (1:5.0.3-1) ... Selecting previously unselected package libxdamage1:amd64. Preparing to unpack .../22-libxdamage1_1%3a1.1.4-2+b3_amd64.deb ... Unpacking libxdamage1:amd64 (1:1.1.4-2+b3) ... Selecting previously unselected package libxext6:amd64. Preparing to unpack .../23-libxext6_2%3a1.3.3-1+b2_amd64.deb ... Unpacking libxext6:amd64 (2:1.3.3-1+b2) ... Selecting previously unselected package libxshmfence1:amd64. Preparing to unpack .../24-libxshmfence1_1.2-1+b2_amd64.deb ... Unpacking libxshmfence1:amd64 (1.2-1+b2) ... Selecting previously unselected package libxxf86vm1:amd64. Preparing to unpack .../25-libxxf86vm1_1%3a1.1.4-1+b2_amd64.deb ... Unpacking libxxf86vm1:amd64 (1:1.1.4-1+b2) ... Selecting previously unselected package libgl1-mesa-glx:amd64. Preparing to unpack .../26-libgl1-mesa-glx_13.0.6-1+b2_amd64.deb ... Unpacking libgl1-mesa-glx:amd64 (13.0.6-1+b2) ... Selecting previously unselected package libtxc-dxtn-s2tc:amd64. Preparing to unpack .../27-libtxc-dxtn-s2tc_1.0+git20151227-2_amd64.deb ... Unpacking libtxc-dxtn-s2tc:amd64 (1.0+git20151227-2) ... Setting up libxshmfence1:amd64 (1.2-1+b2) ... Setting up libllvm3.9:amd64 (1:3.9.1-9) ... Setting up libtxc-dxtn-s2tc:amd64 (1.0+git20151227-2) ... update-alternatives: using /usr/lib/x86_64-linux-gnu/s2tc/libtxc_dxtn.so to provide /usr/lib/x86_64-linux-gnu/libtxc_dxtn.so (libtxc-dxtn-x86_64-linux-gnu) in auto mode Setting up libglapi-mesa:amd64 (13.0.6-1+b2) ... Setting up libdrm2:amd64 (2.4.74-1) ... Setting up libx11-xcb1:amd64 (2:1.6.4-3) ... Processing triggers for libc-bin (2.24-11+deb9u3) ... Setting up libpciaccess0:amd64 (0.13.4-1+b2) ... Setting up libsensors4:amd64 (1:3.4.0-4) ... Setting up libdrm-radeon1:amd64 (2.4.74-1) ... Setting up libxdmcp6:amd64 (1:1.1.2-3) ... Setting up libdrm-nouveau2:amd64 (2.4.74-1) ... Setting up libx11-data (2:1.6.4-3) ... Setting up libxau6:amd64 (1:1.0.8-1) ... Setting up libdrm-amdgpu1:amd64 (2.4.74-1) ... Setting up libdrm-intel1:amd64 (2.4.74-1) ... Setting up libxcb1:amd64 (1.12-1) ... Setting up libxcb-present0:amd64 (1.12-1) ... Setting up libxcb-dri2-0:amd64 (1.12-1) ... Setting up libxcb-dri3-0:amd64 (1.12-1) ... Setting up libxcb-glx0:amd64 (1.12-1) ... Setting up libx11-6:amd64 (2:1.6.4-3) ... Setting up libgl1-mesa-dri:amd64 (13.0.6-1+b2) ... Setting up libxcb-sync1:amd64 (1.12-1) ... Setting up libxext6:amd64 (2:1.3.3-1+b2) ... Setting up libxfixes3:amd64 (1:5.0.3-1) ... Setting up libxxf86vm1:amd64 (1:1.1.4-1+b2) ... Setting up libxdamage1:amd64 (1:1.1.4-2+b3) ... Setting up libgl1-mesa-glx:amd64 (13.0.6-1+b2) ... Processing triggers for libc-bin (2.24-11+deb9u3) ...

root@test1:/home/work/Electrum-3.1.3# python3 electrum

This application failed to start because it could not find or load the Qt platform plugin "xcb"
in "".

Available platform plugins are: eglfs, linuxfb, minimal, minimalegl, offscreen, vnc, xcb.

Reinstalling the application may fix this problem.
Aborted

Earlier, when installin pyqt5, this appeared in the output:

The scripts pylupdate5, pyrcc5 and pyuic5 are installed in '/root/.local/bin' which is not on PATH. Consider adding this directory to PATH or, if you prefer to suppress this warning, use --no-warn-script-location.

root@test1:/home/work/Electrum-3.1.3# echo $PATH

/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

root@test1:/home/work/Electrum-3.1.3# export PATH=$PATH:/root/.local/bin

root@test1:/home/work/Electrum-3.1.3# python3 electrum

Hm.

From an earlier excerpt:
- In the electrum directory, run: 'python3 electrum'
- To install it on your system, run: 'sudo python3 setup.py install'

I had thought that the

python3 electrum

was part of the installation sequence, since it appeared prior to

sudo python3 setup.py install

.

Perhaps it's not, and

sudo python3 setup.py install

should be run first.

root@test1:/home/work/Electrum-3.1.3# python3 setup.py install

running install
running bdist_egg
running egg_info
writing Electrum.egg-info/PKG-INFO
writing dependency_links to Electrum.egg-info/dependency_links.txt
writing top-level names to Electrum.egg-info/top_level.txt
writing requirements to Electrum.egg-info/requires.txt
reading manifest file 'Electrum.egg-info/SOURCES.txt'
reading manifest template 'MANIFEST.in'
writing manifest file 'Electrum.egg-info/SOURCES.txt'
installing library code to build/bdist.linux-x86_64/egg
running install_lib
running build_py
creating build
creating build/lib
creating build/lib/electrum
copying lib/base_wizard.py -> build/lib/electrum
copying lib/rsakey.py -> build/lib/electrum
copying lib/coinchooser.py -> build/lib/electrum
copying lib/paymentrequest_pb2.py -> build/lib/electrum
copying lib/plugins.py -> build/lib/electrum
copying lib/commands.py -> build/lib/electrum
copying lib/msqr.py -> build/lib/electrum
copying lib/transaction.py -> build/lib/electrum
copying lib/dnssec.py -> build/lib/electrum
copying lib/pem.py -> build/lib/electrum
copying lib/plot.py -> build/lib/electrum
copying lib/ripemd.py -> build/lib/electrum
copying lib/constants.py -> build/lib/electrum
copying lib/keystore.py -> build/lib/electrum
copying lib/network.py -> build/lib/electrum
copying lib/contacts.py -> build/lib/electrum
copying lib/paymentrequest.py -> build/lib/electrum
copying lib/__init__.py -> build/lib/electrum
copying lib/daemon.py -> build/lib/electrum
copying lib/old_mnemonic.py -> build/lib/electrum
copying lib/segwit_addr.py -> build/lib/electrum
copying lib/x509.py -> build/lib/electrum
copying lib/verifier.py -> build/lib/electrum
copying lib/storage.py -> build/lib/electrum
copying lib/jsonrpc.py -> build/lib/electrum
copying lib/interface.py -> build/lib/electrum
copying lib/mnemonic.py -> build/lib/electrum
copying lib/blockchain.py -> build/lib/electrum
copying lib/version.py -> build/lib/electrum
copying lib/synchronizer.py -> build/lib/electrum
copying lib/bitcoin.py -> build/lib/electrum
copying lib/i18n.py -> build/lib/electrum
copying lib/wallet.py -> build/lib/electrum
copying lib/simple_config.py -> build/lib/electrum
copying lib/qrscanner.py -> build/lib/electrum
copying lib/websockets.py -> build/lib/electrum
copying lib/util.py -> build/lib/electrum
copying lib/fee_estimator.py -> build/lib/electrum
copying lib/exchange_rate.py -> build/lib/electrum
creating build/lib/electrum_gui
copying gui/stdio.py -> build/lib/electrum_gui
copying gui/__init__.py -> build/lib/electrum_gui
copying gui/text.py -> build/lib/electrum_gui
creating build/lib/electrum_gui/qt
copying gui/qt/icons_rc.py -> build/lib/electrum_gui/qt
copying gui/qt/history_list.py -> build/lib/electrum_gui/qt
copying gui/qt/amountedit.py -> build/lib/electrum_gui/qt
copying gui/qt/seed_dialog.py -> build/lib/electrum_gui/qt
copying gui/qt/request_list.py -> build/lib/electrum_gui/qt
copying gui/qt/__init__.py -> build/lib/electrum_gui/qt
copying gui/qt/exception_window.py -> build/lib/electrum_gui/qt
copying gui/qt/address_dialog.py -> build/lib/electrum_gui/qt
copying gui/qt/contact_list.py -> build/lib/electrum_gui/qt
copying gui/qt/address_list.py -> build/lib/electrum_gui/qt
copying gui/qt/qrtextedit.py -> build/lib/electrum_gui/qt
copying gui/qt/installwizard.py -> build/lib/electrum_gui/qt
copying gui/qt/qrcodewidget.py -> build/lib/electrum_gui/qt
copying gui/qt/main_window.py -> build/lib/electrum_gui/qt
copying gui/qt/console.py -> build/lib/electrum_gui/qt
copying gui/qt/password_dialog.py -> build/lib/electrum_gui/qt
copying gui/qt/network_dialog.py -> build/lib/electrum_gui/qt
copying gui/qt/util.py -> build/lib/electrum_gui/qt
copying gui/qt/paytoedit.py -> build/lib/electrum_gui/qt
copying gui/qt/fee_slider.py -> build/lib/electrum_gui/qt
copying gui/qt/qrwindow.py -> build/lib/electrum_gui/qt
copying gui/qt/transaction_dialog.py -> build/lib/electrum_gui/qt
copying gui/qt/completion_text_edit.py -> build/lib/electrum_gui/qt
copying gui/qt/invoice_list.py -> build/lib/electrum_gui/qt
copying gui/qt/utxo_list.py -> build/lib/electrum_gui/qt
creating build/lib/electrum_plugins
copying plugins/__init__.py -> build/lib/electrum_plugins
creating build/lib/electrum_plugins/audio_modem
copying plugins/audio_modem/__init__.py -> build/lib/electrum_plugins/audio_modem
copying plugins/audio_modem/qt.py -> build/lib/electrum_plugins/audio_modem
creating build/lib/electrum_plugins/cosigner_pool
copying plugins/cosigner_pool/__init__.py -> build/lib/electrum_plugins/cosigner_pool
copying plugins/cosigner_pool/qt.py -> build/lib/electrum_plugins/cosigner_pool
creating build/lib/electrum_plugins/email_requests
copying plugins/email_requests/__init__.py -> build/lib/electrum_plugins/email_requests
copying plugins/email_requests/qt.py -> build/lib/electrum_plugins/email_requests
creating build/lib/electrum_plugins/greenaddress_instant
copying plugins/greenaddress_instant/__init__.py -> build/lib/electrum_plugins/greenaddress_instant
copying plugins/greenaddress_instant/qt.py -> build/lib/electrum_plugins/greenaddress_instant
creating build/lib/electrum_plugins/hw_wallet
copying plugins/hw_wallet/plugin.py -> build/lib/electrum_plugins/hw_wallet
copying plugins/hw_wallet/__init__.py -> build/lib/electrum_plugins/hw_wallet
copying plugins/hw_wallet/cmdline.py -> build/lib/electrum_plugins/hw_wallet
copying plugins/hw_wallet/qt.py -> build/lib/electrum_plugins/hw_wallet
creating build/lib/electrum_plugins/keepkey
copying plugins/keepkey/plugin.py -> build/lib/electrum_plugins/keepkey
copying plugins/keepkey/__init__.py -> build/lib/electrum_plugins/keepkey
copying plugins/keepkey/cmdline.py -> build/lib/electrum_plugins/keepkey
copying plugins/keepkey/client.py -> build/lib/electrum_plugins/keepkey
copying plugins/keepkey/qt_generic.py -> build/lib/electrum_plugins/keepkey
copying plugins/keepkey/clientbase.py -> build/lib/electrum_plugins/keepkey
copying plugins/keepkey/keepkey.py -> build/lib/electrum_plugins/keepkey
copying plugins/keepkey/qt.py -> build/lib/electrum_plugins/keepkey
creating build/lib/electrum_plugins/labels
copying plugins/labels/__init__.py -> build/lib/electrum_plugins/labels
copying plugins/labels/kivy.py -> build/lib/electrum_plugins/labels
copying plugins/labels/labels.py -> build/lib/electrum_plugins/labels
copying plugins/labels/qt.py -> build/lib/electrum_plugins/labels
creating build/lib/electrum_plugins/ledger
copying plugins/ledger/__init__.py -> build/lib/electrum_plugins/ledger
copying plugins/ledger/cmdline.py -> build/lib/electrum_plugins/ledger
copying plugins/ledger/ledger.py -> build/lib/electrum_plugins/ledger
copying plugins/ledger/auth2fa.py -> build/lib/electrum_plugins/ledger
copying plugins/ledger/qt.py -> build/lib/electrum_plugins/ledger
creating build/lib/electrum_plugins/trezor
copying plugins/trezor/transport.py -> build/lib/electrum_plugins/trezor
copying plugins/trezor/__init__.py -> build/lib/electrum_plugins/trezor
copying plugins/trezor/cmdline.py -> build/lib/electrum_plugins/trezor
copying plugins/trezor/client.py -> build/lib/electrum_plugins/trezor
copying plugins/trezor/trezor.py -> build/lib/electrum_plugins/trezor
copying plugins/trezor/qt_generic.py -> build/lib/electrum_plugins/trezor
copying plugins/trezor/clientbase.py -> build/lib/electrum_plugins/trezor
copying plugins/trezor/qt.py -> build/lib/electrum_plugins/trezor
creating build/lib/electrum_plugins/digitalbitbox
copying plugins/digitalbitbox/__init__.py -> build/lib/electrum_plugins/digitalbitbox
copying plugins/digitalbitbox/cmdline.py -> build/lib/electrum_plugins/digitalbitbox
copying plugins/digitalbitbox/digitalbitbox.py -> build/lib/electrum_plugins/digitalbitbox
copying plugins/digitalbitbox/qt.py -> build/lib/electrum_plugins/digitalbitbox
creating build/lib/electrum_plugins/trustedcoin
copying plugins/trustedcoin/trustedcoin.py -> build/lib/electrum_plugins/trustedcoin
copying plugins/trustedcoin/__init__.py -> build/lib/electrum_plugins/trustedcoin
copying plugins/trustedcoin/cmdline.py -> build/lib/electrum_plugins/trustedcoin
copying plugins/trustedcoin/qt.py -> build/lib/electrum_plugins/trustedcoin
creating build/lib/electrum_plugins/virtualkeyboard
copying plugins/virtualkeyboard/__init__.py -> build/lib/electrum_plugins/virtualkeyboard
copying plugins/virtualkeyboard/qt.py -> build/lib/electrum_plugins/virtualkeyboard
copying lib/servers.json -> build/lib/electrum
copying lib/servers_testnet.json -> build/lib/electrum
copying lib/servers_regtest.json -> build/lib/electrum
copying lib/currencies.json -> build/lib/electrum
copying lib/checkpoints.json -> build/lib/electrum
copying lib/checkpoints_testnet.json -> build/lib/electrum
creating build/lib/electrum/wordlist
copying lib/wordlist/spanish.txt -> build/lib/electrum/wordlist
copying lib/wordlist/portuguese.txt -> build/lib/electrum/wordlist
copying lib/wordlist/chinese_simplified.txt -> build/lib/electrum/wordlist
copying lib/wordlist/japanese.txt -> build/lib/electrum/wordlist
copying lib/wordlist/english.txt -> build/lib/electrum/wordlist
creating build/lib/electrum/locale
creating build/lib/electrum/locale/bg_BG
creating build/lib/electrum/locale/bg_BG/LC_MESSAGES
copying lib/locale/bg_BG/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/bg_BG/LC_MESSAGES
creating build/lib/electrum/locale/ru_RU
creating build/lib/electrum/locale/ru_RU/LC_MESSAGES
copying lib/locale/ru_RU/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/ru_RU/LC_MESSAGES
creating build/lib/electrum/locale/ja_JP
creating build/lib/electrum/locale/ja_JP/LC_MESSAGES
copying lib/locale/ja_JP/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/ja_JP/LC_MESSAGES
creating build/lib/electrum/locale/sl_SI
creating build/lib/electrum/locale/sl_SI/LC_MESSAGES
copying lib/locale/sl_SI/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/sl_SI/LC_MESSAGES
creating build/lib/electrum/locale/pl_PL
creating build/lib/electrum/locale/pl_PL/LC_MESSAGES
copying lib/locale/pl_PL/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/pl_PL/LC_MESSAGES
creating build/lib/electrum/locale/fa_IR
creating build/lib/electrum/locale/fa_IR/LC_MESSAGES
copying lib/locale/fa_IR/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/fa_IR/LC_MESSAGES
creating build/lib/electrum/locale/pt_PT
creating build/lib/electrum/locale/pt_PT/LC_MESSAGES
copying lib/locale/pt_PT/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/pt_PT/LC_MESSAGES
creating build/lib/electrum/locale/it_IT
creating build/lib/electrum/locale/it_IT/LC_MESSAGES
copying lib/locale/it_IT/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/it_IT/LC_MESSAGES
creating build/lib/electrum/locale/nb_NO
creating build/lib/electrum/locale/nb_NO/LC_MESSAGES
copying lib/locale/nb_NO/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/nb_NO/LC_MESSAGES
creating build/lib/electrum/locale/eo_UY
creating build/lib/electrum/locale/eo_UY/LC_MESSAGES
copying lib/locale/eo_UY/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/eo_UY/LC_MESSAGES
creating build/lib/electrum/locale/zh_CN
creating build/lib/electrum/locale/zh_CN/LC_MESSAGES
copying lib/locale/zh_CN/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/zh_CN/LC_MESSAGES
creating build/lib/electrum/locale/th_TH
creating build/lib/electrum/locale/th_TH/LC_MESSAGES
copying lib/locale/th_TH/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/th_TH/LC_MESSAGES
creating build/lib/electrum/locale/lv_LV
creating build/lib/electrum/locale/lv_LV/LC_MESSAGES
copying lib/locale/lv_LV/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/lv_LV/LC_MESSAGES
creating build/lib/electrum/locale/uk_UA
creating build/lib/electrum/locale/uk_UA/LC_MESSAGES
copying lib/locale/uk_UA/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/uk_UA/LC_MESSAGES
creating build/lib/electrum/locale/fr_FR
creating build/lib/electrum/locale/fr_FR/LC_MESSAGES
copying lib/locale/fr_FR/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/fr_FR/LC_MESSAGES
creating build/lib/electrum/locale/vi_VN
creating build/lib/electrum/locale/vi_VN/LC_MESSAGES
copying lib/locale/vi_VN/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/vi_VN/LC_MESSAGES
creating build/lib/electrum/locale/id_ID
creating build/lib/electrum/locale/id_ID/LC_MESSAGES
copying lib/locale/id_ID/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/id_ID/LC_MESSAGES
creating build/lib/electrum/locale/de_DE
creating build/lib/electrum/locale/de_DE/LC_MESSAGES
copying lib/locale/de_DE/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/de_DE/LC_MESSAGES
creating build/lib/electrum/locale/cs_CZ
creating build/lib/electrum/locale/cs_CZ/LC_MESSAGES
copying lib/locale/cs_CZ/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/cs_CZ/LC_MESSAGES
creating build/lib/electrum/locale/zh_TW
creating build/lib/electrum/locale/zh_TW/LC_MESSAGES
copying lib/locale/zh_TW/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/zh_TW/LC_MESSAGES
creating build/lib/electrum/locale/es_ES
creating build/lib/electrum/locale/es_ES/LC_MESSAGES
copying lib/locale/es_ES/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/es_ES/LC_MESSAGES
creating build/lib/electrum/locale/ko_KR
creating build/lib/electrum/locale/ko_KR/LC_MESSAGES
copying lib/locale/ko_KR/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/ko_KR/LC_MESSAGES
creating build/lib/electrum/locale/nl_NL
creating build/lib/electrum/locale/nl_NL/LC_MESSAGES
copying lib/locale/nl_NL/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/nl_NL/LC_MESSAGES
creating build/lib/electrum/locale/da_DK
creating build/lib/electrum/locale/da_DK/LC_MESSAGES
copying lib/locale/da_DK/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/da_DK/LC_MESSAGES
creating build/lib/electrum/locale/ro_RO
creating build/lib/electrum/locale/ro_RO/LC_MESSAGES
copying lib/locale/ro_RO/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/ro_RO/LC_MESSAGES
creating build/lib/electrum/locale/pt_BR
creating build/lib/electrum/locale/pt_BR/LC_MESSAGES
copying lib/locale/pt_BR/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/pt_BR/LC_MESSAGES
creating build/lib/electrum/locale/ky_KG
creating build/lib/electrum/locale/ky_KG/LC_MESSAGES
copying lib/locale/ky_KG/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/ky_KG/LC_MESSAGES
creating build/lib/electrum/locale/sk_SK
creating build/lib/electrum/locale/sk_SK/LC_MESSAGES
copying lib/locale/sk_SK/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/sk_SK/LC_MESSAGES
creating build/lib/electrum/locale/hu_HU
creating build/lib/electrum/locale/hu_HU/LC_MESSAGES
copying lib/locale/hu_HU/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/hu_HU/LC_MESSAGES
creating build/lib/electrum/locale/tr_TR
creating build/lib/electrum/locale/tr_TR/LC_MESSAGES
copying lib/locale/tr_TR/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/tr_TR/LC_MESSAGES
creating build/lib/electrum/locale/ta_IN
creating build/lib/electrum/locale/ta_IN/LC_MESSAGES
copying lib/locale/ta_IN/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/ta_IN/LC_MESSAGES
creating build/lib/electrum/locale/ar_SA
creating build/lib/electrum/locale/ar_SA/LC_MESSAGES
copying lib/locale/ar_SA/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/ar_SA/LC_MESSAGES
creating build/lib/electrum/locale/sv_SE
creating build/lib/electrum/locale/sv_SE/LC_MESSAGES
copying lib/locale/sv_SE/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/sv_SE/LC_MESSAGES
creating build/lib/electrum/locale/el_GR
creating build/lib/electrum/locale/el_GR/LC_MESSAGES
copying lib/locale/el_GR/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/el_GR/LC_MESSAGES
creating build/lib/electrum/locale/hy_AM
creating build/lib/electrum/locale/hy_AM/LC_MESSAGES
copying lib/locale/hy_AM/LC_MESSAGES/electrum.mo -> build/lib/electrum/locale/hy_AM/LC_MESSAGES
creating build/bdist.linux-x86_64
creating build/bdist.linux-x86_64/egg
creating build/bdist.linux-x86_64/egg/electrum_gui
creating build/bdist.linux-x86_64/egg/electrum_gui/qt
copying build/lib/electrum_gui/qt/icons_rc.py -> build/bdist.linux-x86_64/egg/electrum_gui/qt
copying build/lib/electrum_gui/qt/history_list.py -> build/bdist.linux-x86_64/egg/electrum_gui/qt
copying build/lib/electrum_gui/qt/amountedit.py -> build/bdist.linux-x86_64/egg/electrum_gui/qt
copying build/lib/electrum_gui/qt/seed_dialog.py -> build/bdist.linux-x86_64/egg/electrum_gui/qt
copying build/lib/electrum_gui/qt/request_list.py -> build/bdist.linux-x86_64/egg/electrum_gui/qt
copying build/lib/electrum_gui/qt/__init__.py -> build/bdist.linux-x86_64/egg/electrum_gui/qt
copying build/lib/electrum_gui/qt/exception_window.py -> build/bdist.linux-x86_64/egg/electrum_gui/qt
copying build/lib/electrum_gui/qt/address_dialog.py -> build/bdist.linux-x86_64/egg/electrum_gui/qt
copying build/lib/electrum_gui/qt/contact_list.py -> build/bdist.linux-x86_64/egg/electrum_gui/qt
copying build/lib/electrum_gui/qt/address_list.py -> build/bdist.linux-x86_64/egg/electrum_gui/qt
copying build/lib/electrum_gui/qt/qrtextedit.py -> build/bdist.linux-x86_64/egg/electrum_gui/qt
copying build/lib/electrum_gui/qt/installwizard.py -> build/bdist.linux-x86_64/egg/electrum_gui/qt
copying build/lib/electrum_gui/qt/qrcodewidget.py -> build/bdist.linux-x86_64/egg/electrum_gui/qt
copying build/lib/electrum_gui/qt/main_window.py -> build/bdist.linux-x86_64/egg/electrum_gui/qt
copying build/lib/electrum_gui/qt/console.py -> build/bdist.linux-x86_64/egg/electrum_gui/qt
copying build/lib/electrum_gui/qt/password_dialog.py -> build/bdist.linux-x86_64/egg/electrum_gui/qt
copying build/lib/electrum_gui/qt/network_dialog.py -> build/bdist.linux-x86_64/egg/electrum_gui/qt
copying build/lib/electrum_gui/qt/util.py -> build/bdist.linux-x86_64/egg/electrum_gui/qt
copying build/lib/electrum_gui/qt/paytoedit.py -> build/bdist.linux-x86_64/egg/electrum_gui/qt
copying build/lib/electrum_gui/qt/fee_slider.py -> build/bdist.linux-x86_64/egg/electrum_gui/qt
copying build/lib/electrum_gui/qt/qrwindow.py -> build/bdist.linux-x86_64/egg/electrum_gui/qt
copying build/lib/electrum_gui/qt/transaction_dialog.py -> build/bdist.linux-x86_64/egg/electrum_gui/qt
copying build/lib/electrum_gui/qt/completion_text_edit.py -> build/bdist.linux-x86_64/egg/electrum_gui/qt
copying build/lib/electrum_gui/qt/invoice_list.py -> build/bdist.linux-x86_64/egg/electrum_gui/qt
copying build/lib/electrum_gui/qt/utxo_list.py -> build/bdist.linux-x86_64/egg/electrum_gui/qt
copying build/lib/electrum_gui/stdio.py -> build/bdist.linux-x86_64/egg/electrum_gui
copying build/lib/electrum_gui/__init__.py -> build/bdist.linux-x86_64/egg/electrum_gui
copying build/lib/electrum_gui/text.py -> build/bdist.linux-x86_64/egg/electrum_gui
creating build/bdist.linux-x86_64/egg/electrum_plugins
creating build/bdist.linux-x86_64/egg/electrum_plugins/keepkey
copying build/lib/electrum_plugins/keepkey/plugin.py -> build/bdist.linux-x86_64/egg/electrum_plugins/keepkey
copying build/lib/electrum_plugins/keepkey/__init__.py -> build/bdist.linux-x86_64/egg/electrum_plugins/keepkey
copying build/lib/electrum_plugins/keepkey/cmdline.py -> build/bdist.linux-x86_64/egg/electrum_plugins/keepkey
copying build/lib/electrum_plugins/keepkey/client.py -> build/bdist.linux-x86_64/egg/electrum_plugins/keepkey
copying build/lib/electrum_plugins/keepkey/qt_generic.py -> build/bdist.linux-x86_64/egg/electrum_plugins/keepkey
copying build/lib/electrum_plugins/keepkey/clientbase.py -> build/bdist.linux-x86_64/egg/electrum_plugins/keepkey
copying build/lib/electrum_plugins/keepkey/keepkey.py -> build/bdist.linux-x86_64/egg/electrum_plugins/keepkey
copying build/lib/electrum_plugins/keepkey/qt.py -> build/bdist.linux-x86_64/egg/electrum_plugins/keepkey
creating build/bdist.linux-x86_64/egg/electrum_plugins/greenaddress_instant
copying build/lib/electrum_plugins/greenaddress_instant/__init__.py -> build/bdist.linux-x86_64/egg/electrum_plugins/greenaddress_instant
copying build/lib/electrum_plugins/greenaddress_instant/qt.py -> build/bdist.linux-x86_64/egg/electrum_plugins/greenaddress_instant
creating build/bdist.linux-x86_64/egg/electrum_plugins/virtualkeyboard
copying build/lib/electrum_plugins/virtualkeyboard/__init__.py -> build/bdist.linux-x86_64/egg/electrum_plugins/virtualkeyboard
copying build/lib/electrum_plugins/virtualkeyboard/qt.py -> build/bdist.linux-x86_64/egg/electrum_plugins/virtualkeyboard
creating build/bdist.linux-x86_64/egg/electrum_plugins/labels
copying build/lib/electrum_plugins/labels/__init__.py -> build/bdist.linux-x86_64/egg/electrum_plugins/labels
copying build/lib/electrum_plugins/labels/kivy.py -> build/bdist.linux-x86_64/egg/electrum_plugins/labels
copying build/lib/electrum_plugins/labels/labels.py -> build/bdist.linux-x86_64/egg/electrum_plugins/labels
copying build/lib/electrum_plugins/labels/qt.py -> build/bdist.linux-x86_64/egg/electrum_plugins/labels
creating build/bdist.linux-x86_64/egg/electrum_plugins/trezor
copying build/lib/electrum_plugins/trezor/transport.py -> build/bdist.linux-x86_64/egg/electrum_plugins/trezor
copying build/lib/electrum_plugins/trezor/__init__.py -> build/bdist.linux-x86_64/egg/electrum_plugins/trezor
copying build/lib/electrum_plugins/trezor/cmdline.py -> build/bdist.linux-x86_64/egg/electrum_plugins/trezor
copying build/lib/electrum_plugins/trezor/client.py -> build/bdist.linux-x86_64/egg/electrum_plugins/trezor
copying build/lib/electrum_plugins/trezor/trezor.py -> build/bdist.linux-x86_64/egg/electrum_plugins/trezor
copying build/lib/electrum_plugins/trezor/qt_generic.py -> build/bdist.linux-x86_64/egg/electrum_plugins/trezor
copying build/lib/electrum_plugins/trezor/clientbase.py -> build/bdist.linux-x86_64/egg/electrum_plugins/trezor
copying build/lib/electrum_plugins/trezor/qt.py -> build/bdist.linux-x86_64/egg/electrum_plugins/trezor
creating build/bdist.linux-x86_64/egg/electrum_plugins/hw_wallet
copying build/lib/electrum_plugins/hw_wallet/plugin.py -> build/bdist.linux-x86_64/egg/electrum_plugins/hw_wallet
copying build/lib/electrum_plugins/hw_wallet/__init__.py -> build/bdist.linux-x86_64/egg/electrum_plugins/hw_wallet
copying build/lib/electrum_plugins/hw_wallet/cmdline.py -> build/bdist.linux-x86_64/egg/electrum_plugins/hw_wallet
copying build/lib/electrum_plugins/hw_wallet/qt.py -> build/bdist.linux-x86_64/egg/electrum_plugins/hw_wallet
copying build/lib/electrum_plugins/__init__.py -> build/bdist.linux-x86_64/egg/electrum_plugins
creating build/bdist.linux-x86_64/egg/electrum_plugins/digitalbitbox
copying build/lib/electrum_plugins/digitalbitbox/__init__.py -> build/bdist.linux-x86_64/egg/electrum_plugins/digitalbitbox
copying build/lib/electrum_plugins/digitalbitbox/cmdline.py -> build/bdist.linux-x86_64/egg/electrum_plugins/digitalbitbox
copying build/lib/electrum_plugins/digitalbitbox/digitalbitbox.py -> build/bdist.linux-x86_64/egg/electrum_plugins/digitalbitbox
copying build/lib/electrum_plugins/digitalbitbox/qt.py -> build/bdist.linux-x86_64/egg/electrum_plugins/digitalbitbox
creating build/bdist.linux-x86_64/egg/electrum_plugins/email_requests
copying build/lib/electrum_plugins/email_requests/__init__.py -> build/bdist.linux-x86_64/egg/electrum_plugins/email_requests
copying build/lib/electrum_plugins/email_requests/qt.py -> build/bdist.linux-x86_64/egg/electrum_plugins/email_requests
creating build/bdist.linux-x86_64/egg/electrum_plugins/cosigner_pool
copying build/lib/electrum_plugins/cosigner_pool/__init__.py -> build/bdist.linux-x86_64/egg/electrum_plugins/cosigner_pool
copying build/lib/electrum_plugins/cosigner_pool/qt.py -> build/bdist.linux-x86_64/egg/electrum_plugins/cosigner_pool
creating build/bdist.linux-x86_64/egg/electrum_plugins/trustedcoin
copying build/lib/electrum_plugins/trustedcoin/trustedcoin.py -> build/bdist.linux-x86_64/egg/electrum_plugins/trustedcoin
copying build/lib/electrum_plugins/trustedcoin/__init__.py -> build/bdist.linux-x86_64/egg/electrum_plugins/trustedcoin
copying build/lib/electrum_plugins/trustedcoin/cmdline.py -> build/bdist.linux-x86_64/egg/electrum_plugins/trustedcoin
copying build/lib/electrum_plugins/trustedcoin/qt.py -> build/bdist.linux-x86_64/egg/electrum_plugins/trustedcoin
creating build/bdist.linux-x86_64/egg/electrum_plugins/audio_modem
copying build/lib/electrum_plugins/audio_modem/__init__.py -> build/bdist.linux-x86_64/egg/electrum_plugins/audio_modem
copying build/lib/electrum_plugins/audio_modem/qt.py -> build/bdist.linux-x86_64/egg/electrum_plugins/audio_modem
creating build/bdist.linux-x86_64/egg/electrum_plugins/ledger
copying build/lib/electrum_plugins/ledger/__init__.py -> build/bdist.linux-x86_64/egg/electrum_plugins/ledger
copying build/lib/electrum_plugins/ledger/cmdline.py -> build/bdist.linux-x86_64/egg/electrum_plugins/ledger
copying build/lib/electrum_plugins/ledger/ledger.py -> build/bdist.linux-x86_64/egg/electrum_plugins/ledger
copying build/lib/electrum_plugins/ledger/auth2fa.py -> build/bdist.linux-x86_64/egg/electrum_plugins/ledger
copying build/lib/electrum_plugins/ledger/qt.py -> build/bdist.linux-x86_64/egg/electrum_plugins/ledger
creating build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/base_wizard.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/rsakey.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/coinchooser.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/paymentrequest_pb2.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/plugins.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/commands.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/msqr.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/transaction.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/servers_testnet.json -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/dnssec.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/pem.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/plot.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/ripemd.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/constants.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/keystore.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/network.py -> build/bdist.linux-x86_64/egg/electrum
creating build/bdist.linux-x86_64/egg/electrum/wordlist
copying build/lib/electrum/wordlist/spanish.txt -> build/bdist.linux-x86_64/egg/electrum/wordlist
copying build/lib/electrum/wordlist/portuguese.txt -> build/bdist.linux-x86_64/egg/electrum/wordlist
copying build/lib/electrum/wordlist/chinese_simplified.txt -> build/bdist.linux-x86_64/egg/electrum/wordlist
copying build/lib/electrum/wordlist/japanese.txt -> build/bdist.linux-x86_64/egg/electrum/wordlist
copying build/lib/electrum/wordlist/english.txt -> build/bdist.linux-x86_64/egg/electrum/wordlist
copying build/lib/electrum/contacts.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/paymentrequest.py -> build/bdist.linux-x86_64/egg/electrum
creating build/bdist.linux-x86_64/egg/electrum/locale
creating build/bdist.linux-x86_64/egg/electrum/locale/bg_BG
creating build/bdist.linux-x86_64/egg/electrum/locale/bg_BG/LC_MESSAGES
copying build/lib/electrum/locale/bg_BG/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/bg_BG/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/ru_RU
creating build/bdist.linux-x86_64/egg/electrum/locale/ru_RU/LC_MESSAGES
copying build/lib/electrum/locale/ru_RU/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/ru_RU/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/ja_JP
creating build/bdist.linux-x86_64/egg/electrum/locale/ja_JP/LC_MESSAGES
copying build/lib/electrum/locale/ja_JP/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/ja_JP/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/sl_SI
creating build/bdist.linux-x86_64/egg/electrum/locale/sl_SI/LC_MESSAGES
copying build/lib/electrum/locale/sl_SI/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/sl_SI/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/pl_PL
creating build/bdist.linux-x86_64/egg/electrum/locale/pl_PL/LC_MESSAGES
copying build/lib/electrum/locale/pl_PL/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/pl_PL/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/fa_IR
creating build/bdist.linux-x86_64/egg/electrum/locale/fa_IR/LC_MESSAGES
copying build/lib/electrum/locale/fa_IR/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/fa_IR/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/pt_PT
creating build/bdist.linux-x86_64/egg/electrum/locale/pt_PT/LC_MESSAGES
copying build/lib/electrum/locale/pt_PT/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/pt_PT/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/it_IT
creating build/bdist.linux-x86_64/egg/electrum/locale/it_IT/LC_MESSAGES
copying build/lib/electrum/locale/it_IT/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/it_IT/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/nb_NO
creating build/bdist.linux-x86_64/egg/electrum/locale/nb_NO/LC_MESSAGES
copying build/lib/electrum/locale/nb_NO/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/nb_NO/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/eo_UY
creating build/bdist.linux-x86_64/egg/electrum/locale/eo_UY/LC_MESSAGES
copying build/lib/electrum/locale/eo_UY/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/eo_UY/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/zh_CN
creating build/bdist.linux-x86_64/egg/electrum/locale/zh_CN/LC_MESSAGES
copying build/lib/electrum/locale/zh_CN/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/zh_CN/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/th_TH
creating build/bdist.linux-x86_64/egg/electrum/locale/th_TH/LC_MESSAGES
copying build/lib/electrum/locale/th_TH/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/th_TH/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/lv_LV
creating build/bdist.linux-x86_64/egg/electrum/locale/lv_LV/LC_MESSAGES
copying build/lib/electrum/locale/lv_LV/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/lv_LV/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/uk_UA
creating build/bdist.linux-x86_64/egg/electrum/locale/uk_UA/LC_MESSAGES
copying build/lib/electrum/locale/uk_UA/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/uk_UA/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/fr_FR
creating build/bdist.linux-x86_64/egg/electrum/locale/fr_FR/LC_MESSAGES
copying build/lib/electrum/locale/fr_FR/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/fr_FR/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/vi_VN
creating build/bdist.linux-x86_64/egg/electrum/locale/vi_VN/LC_MESSAGES
copying build/lib/electrum/locale/vi_VN/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/vi_VN/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/id_ID
creating build/bdist.linux-x86_64/egg/electrum/locale/id_ID/LC_MESSAGES
copying build/lib/electrum/locale/id_ID/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/id_ID/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/de_DE
creating build/bdist.linux-x86_64/egg/electrum/locale/de_DE/LC_MESSAGES
copying build/lib/electrum/locale/de_DE/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/de_DE/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/cs_CZ
creating build/bdist.linux-x86_64/egg/electrum/locale/cs_CZ/LC_MESSAGES
copying build/lib/electrum/locale/cs_CZ/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/cs_CZ/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/zh_TW
creating build/bdist.linux-x86_64/egg/electrum/locale/zh_TW/LC_MESSAGES
copying build/lib/electrum/locale/zh_TW/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/zh_TW/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/es_ES
creating build/bdist.linux-x86_64/egg/electrum/locale/es_ES/LC_MESSAGES
copying build/lib/electrum/locale/es_ES/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/es_ES/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/ko_KR
creating build/bdist.linux-x86_64/egg/electrum/locale/ko_KR/LC_MESSAGES
copying build/lib/electrum/locale/ko_KR/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/ko_KR/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/nl_NL
creating build/bdist.linux-x86_64/egg/electrum/locale/nl_NL/LC_MESSAGES
copying build/lib/electrum/locale/nl_NL/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/nl_NL/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/da_DK
creating build/bdist.linux-x86_64/egg/electrum/locale/da_DK/LC_MESSAGES
copying build/lib/electrum/locale/da_DK/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/da_DK/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/ro_RO
creating build/bdist.linux-x86_64/egg/electrum/locale/ro_RO/LC_MESSAGES
copying build/lib/electrum/locale/ro_RO/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/ro_RO/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/pt_BR
creating build/bdist.linux-x86_64/egg/electrum/locale/pt_BR/LC_MESSAGES
copying build/lib/electrum/locale/pt_BR/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/pt_BR/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/ky_KG
creating build/bdist.linux-x86_64/egg/electrum/locale/ky_KG/LC_MESSAGES
copying build/lib/electrum/locale/ky_KG/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/ky_KG/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/sk_SK
creating build/bdist.linux-x86_64/egg/electrum/locale/sk_SK/LC_MESSAGES
copying build/lib/electrum/locale/sk_SK/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/sk_SK/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/hu_HU
creating build/bdist.linux-x86_64/egg/electrum/locale/hu_HU/LC_MESSAGES
copying build/lib/electrum/locale/hu_HU/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/hu_HU/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/tr_TR
creating build/bdist.linux-x86_64/egg/electrum/locale/tr_TR/LC_MESSAGES
copying build/lib/electrum/locale/tr_TR/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/tr_TR/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/ta_IN
creating build/bdist.linux-x86_64/egg/electrum/locale/ta_IN/LC_MESSAGES
copying build/lib/electrum/locale/ta_IN/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/ta_IN/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/ar_SA
creating build/bdist.linux-x86_64/egg/electrum/locale/ar_SA/LC_MESSAGES
copying build/lib/electrum/locale/ar_SA/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/ar_SA/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/sv_SE
creating build/bdist.linux-x86_64/egg/electrum/locale/sv_SE/LC_MESSAGES
copying build/lib/electrum/locale/sv_SE/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/sv_SE/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/el_GR
creating build/bdist.linux-x86_64/egg/electrum/locale/el_GR/LC_MESSAGES
copying build/lib/electrum/locale/el_GR/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/el_GR/LC_MESSAGES
creating build/bdist.linux-x86_64/egg/electrum/locale/hy_AM
creating build/bdist.linux-x86_64/egg/electrum/locale/hy_AM/LC_MESSAGES
copying build/lib/electrum/locale/hy_AM/LC_MESSAGES/electrum.mo -> build/bdist.linux-x86_64/egg/electrum/locale/hy_AM/LC_MESSAGES
copying build/lib/electrum/checkpoints_testnet.json -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/__init__.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/servers_regtest.json -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/daemon.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/servers.json -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/old_mnemonic.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/segwit_addr.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/x509.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/verifier.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/storage.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/jsonrpc.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/interface.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/mnemonic.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/blockchain.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/version.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/synchronizer.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/bitcoin.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/i18n.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/wallet.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/simple_config.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/checkpoints.json -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/qrscanner.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/websockets.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/util.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/fee_estimator.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/exchange_rate.py -> build/bdist.linux-x86_64/egg/electrum
copying build/lib/electrum/currencies.json -> build/bdist.linux-x86_64/egg/electrum
byte-compiling build/bdist.linux-x86_64/egg/electrum_gui/qt/icons_rc.py to icons_rc.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_gui/qt/history_list.py to history_list.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_gui/qt/amountedit.py to amountedit.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_gui/qt/seed_dialog.py to seed_dialog.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_gui/qt/request_list.py to request_list.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_gui/qt/__init__.py to __init__.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_gui/qt/exception_window.py to exception_window.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_gui/qt/address_dialog.py to address_dialog.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_gui/qt/contact_list.py to contact_list.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_gui/qt/address_list.py to address_list.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_gui/qt/qrtextedit.py to qrtextedit.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_gui/qt/installwizard.py to installwizard.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_gui/qt/qrcodewidget.py to qrcodewidget.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_gui/qt/main_window.py to main_window.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_gui/qt/console.py to console.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_gui/qt/password_dialog.py to password_dialog.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_gui/qt/network_dialog.py to network_dialog.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_gui/qt/util.py to util.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_gui/qt/paytoedit.py to paytoedit.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_gui/qt/fee_slider.py to fee_slider.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_gui/qt/qrwindow.py to qrwindow.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_gui/qt/transaction_dialog.py to transaction_dialog.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_gui/qt/completion_text_edit.py to completion_text_edit.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_gui/qt/invoice_list.py to invoice_list.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_gui/qt/utxo_list.py to utxo_list.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_gui/stdio.py to stdio.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_gui/__init__.py to __init__.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_gui/text.py to text.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/keepkey/plugin.py to plugin.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/keepkey/__init__.py to __init__.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/keepkey/cmdline.py to cmdline.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/keepkey/client.py to client.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/keepkey/qt_generic.py to qt_generic.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/keepkey/clientbase.py to clientbase.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/keepkey/keepkey.py to keepkey.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/keepkey/qt.py to qt.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/greenaddress_instant/__init__.py to __init__.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/greenaddress_instant/qt.py to qt.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/virtualkeyboard/__init__.py to __init__.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/virtualkeyboard/qt.py to qt.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/labels/__init__.py to __init__.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/labels/kivy.py to kivy.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/labels/labels.py to labels.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/labels/qt.py to qt.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/trezor/transport.py to transport.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/trezor/__init__.py to __init__.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/trezor/cmdline.py to cmdline.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/trezor/client.py to client.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/trezor/trezor.py to trezor.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/trezor/qt_generic.py to qt_generic.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/trezor/clientbase.py to clientbase.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/trezor/qt.py to qt.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/hw_wallet/plugin.py to plugin.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/hw_wallet/__init__.py to __init__.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/hw_wallet/cmdline.py to cmdline.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/hw_wallet/qt.py to qt.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/__init__.py to __init__.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/digitalbitbox/__init__.py to __init__.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/digitalbitbox/cmdline.py to cmdline.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/digitalbitbox/digitalbitbox.py to digitalbitbox.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/digitalbitbox/qt.py to qt.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/email_requests/__init__.py to __init__.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/email_requests/qt.py to qt.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/cosigner_pool/__init__.py to __init__.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/cosigner_pool/qt.py to qt.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/trustedcoin/trustedcoin.py to trustedcoin.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/trustedcoin/__init__.py to __init__.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/trustedcoin/cmdline.py to cmdline.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/trustedcoin/qt.py to qt.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/audio_modem/__init__.py to __init__.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/audio_modem/qt.py to qt.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/ledger/__init__.py to __init__.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/ledger/cmdline.py to cmdline.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/ledger/ledger.py to ledger.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/ledger/auth2fa.py to auth2fa.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum_plugins/ledger/qt.py to qt.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/base_wizard.py to base_wizard.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/rsakey.py to rsakey.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/coinchooser.py to coinchooser.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/paymentrequest_pb2.py to paymentrequest_pb2.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/plugins.py to plugins.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/commands.py to commands.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/msqr.py to msqr.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/transaction.py to transaction.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/dnssec.py to dnssec.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/pem.py to pem.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/plot.py to plot.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/ripemd.py to ripemd.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/constants.py to constants.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/keystore.py to keystore.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/network.py to network.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/contacts.py to contacts.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/paymentrequest.py to paymentrequest.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/__init__.py to __init__.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/daemon.py to daemon.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/old_mnemonic.py to old_mnemonic.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/segwit_addr.py to segwit_addr.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/x509.py to x509.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/verifier.py to verifier.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/storage.py to storage.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/jsonrpc.py to jsonrpc.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/interface.py to interface.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/mnemonic.py to mnemonic.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/blockchain.py to blockchain.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/version.py to version.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/synchronizer.py to synchronizer.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/bitcoin.py to bitcoin.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/i18n.py to i18n.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/wallet.py to wallet.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/simple_config.py to simple_config.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/qrscanner.py to qrscanner.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/websockets.py to websockets.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/util.py to util.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/fee_estimator.py to fee_estimator.cpython-35.pyc
byte-compiling build/bdist.linux-x86_64/egg/electrum/exchange_rate.py to exchange_rate.cpython-35.pyc
installing package data to build/bdist.linux-x86_64/egg
running install_data
copying electrum.desktop -> /usr/share/applications/
copying icons/electrum.png -> /usr/share/pixmaps
creating build/bdist.linux-x86_64/egg/EGG-INFO
installing scripts to build/bdist.linux-x86_64/egg/EGG-INFO/scripts
running install_scripts
running build_scripts
creating build/scripts-3.5
copying and adjusting electrum -> build/scripts-3.5
changing mode of build/scripts-3.5/electrum from 644 to 755
creating build/bdist.linux-x86_64/egg/EGG-INFO/scripts
copying build/scripts-3.5/electrum -> build/bdist.linux-x86_64/egg/EGG-INFO/scripts
changing mode of build/bdist.linux-x86_64/egg/EGG-INFO/scripts/electrum to 755
copying Electrum.egg-info/PKG-INFO -> build/bdist.linux-x86_64/egg/EGG-INFO
copying Electrum.egg-info/SOURCES.txt -> build/bdist.linux-x86_64/egg/EGG-INFO
copying Electrum.egg-info/dependency_links.txt -> build/bdist.linux-x86_64/egg/EGG-INFO
copying Electrum.egg-info/requires.txt -> build/bdist.linux-x86_64/egg/EGG-INFO
copying Electrum.egg-info/top_level.txt -> build/bdist.linux-x86_64/egg/EGG-INFO
zip_safe flag not set; analyzing archive contents...
electrum.__pycache__.i18n.cpython-35: module references __file__
electrum.__pycache__.plugins.cpython-35: module references __file__
electrum.__pycache__.mnemonic.cpython-35: module references __file__
electrum.__pycache__.constants.cpython-35: module references __file__
electrum.__pycache__.exchange_rate.cpython-35: module references __file__
creating dist
creating 'dist/Electrum-3.1.3-py3.5.egg' and adding 'build/bdist.linux-x86_64/egg' to it
removing 'build/bdist.linux-x86_64/egg' (and everything under it)
Processing Electrum-3.1.3-py3.5.egg
creating /usr/local/lib/python3.5/dist-packages/Electrum-3.1.3-py3.5.egg
Extracting Electrum-3.1.3-py3.5.egg to /usr/local/lib/python3.5/dist-packages
Adding Electrum 3.1.3 to easy-install.pth file
Installing electrum script to /usr/local/bin

Installed /usr/local/lib/python3.5/dist-packages/Electrum-3.1.3-py3.5.egg
Processing dependencies for Electrum==3.1.3
Searching for qrcode
Reading https://pypi.python.org/simple/qrcode/
Downloading https://files.pythonhosted.org/packages/8d/b6/beed3d50e1047a2aa6437d3a653e5f31feb7f4de8bc054299dc205682e41/qrcode-6.0.tar.gz#sha256=037b0db4c93f44586e37f84c3da3f763874fcac85b2974a69a98e399ac78e1bf
Best match: qrcode 6.0
Processing qrcode-6.0.tar.gz
Writing /tmp/easy_install-o4918l6k/qrcode-6.0/setup.cfg
Running qrcode-6.0/setup.py -q bdist_egg --dist-dir /tmp/easy_install-o4918l6k/qrcode-6.0/egg-dist-tmp-e8t_cx4h
creating /usr/local/lib/python3.5/dist-packages/qrcode-6.0-py3.5.egg
Extracting qrcode-6.0-py3.5.egg to /usr/local/lib/python3.5/dist-packages
Adding qrcode 6.0 to easy-install.pth file
Installing qr script to /usr/local/bin

Installed /usr/local/lib/python3.5/dist-packages/qrcode-6.0-py3.5.egg
Searching for pyaes>=0.1a1
Reading https://pypi.python.org/simple/pyaes/
Downloading https://files.pythonhosted.org/packages/44/66/2c17bae31c906613795711fc78045c285048168919ace2220daa372c7d72/pyaes-1.6.1.tar.gz#sha256=02c1b1405c38d3c370b085fb952dd8bea3fadcee6411ad99f312cc129c536d8f
Best match: pyaes 1.6.1
Processing pyaes-1.6.1.tar.gz
Writing /tmp/easy_install-1_t6gdk9/pyaes-1.6.1/setup.cfg
Running pyaes-1.6.1/setup.py -q bdist_egg --dist-dir /tmp/easy_install-1_t6gdk9/pyaes-1.6.1/egg-dist-tmp-p5vr3wok
zip_safe flag not set; analyzing archive contents...
Moving pyaes-1.6.1-py3.5.egg to /usr/local/lib/python3.5/dist-packages
Adding pyaes 1.6.1 to easy-install.pth file

Installed /usr/local/lib/python3.5/dist-packages/pyaes-1.6.1-py3.5.egg
Searching for protobuf
Reading https://pypi.python.org/simple/protobuf/
Downloading https://files.pythonhosted.org/packages/73/73/4f133a31d67b27431fe4b9cc5e2f74d0644bce0327a743093f3cc27864ce/protobuf-3.5.2.post1.tar.gz#sha256=3b60685732bd0cbdc802dfcb6071efbcf5d927ce3127c13c33ea1a8efae3aa76
Best match: protobuf 3.5.2.post1
Processing protobuf-3.5.2.post1.tar.gz
Writing /tmp/easy_install-fuvaa86g/protobuf-3.5.2.post1/setup.cfg
Running protobuf-3.5.2.post1/setup.py -q bdist_egg --dist-dir /tmp/easy_install-fuvaa86g/protobuf-3.5.2.post1/egg-dist-tmp-jbxsfqfj
no previously-included directories found matching 'google/protobuf/internal/import_test_package'
warning: no previously-included files found matching 'google/protobuf/internal/*_pb2.py'
warning: no previously-included files found matching 'google/protobuf/internal/*_test.py'
warning: no previously-included files found matching 'google/protobuf/internal/*.proto'
warning: no previously-included files found matching 'google/protobuf/internal/test_util.py'
warning: no previously-included files matching '*_test.py' found under directory 'google'
warning: no previously-included files matching '*_test.proto' found under directory 'google'
warning: no previously-included files matching 'unittest*_pb2.py' found under directory 'google'
warning: no previously-included files matching '*.dll' found anywhere in distribution
warning: no previously-included files matching '*.pyc' found anywhere in distribution
warning: no previously-included files matching '*.pyo' found anywhere in distribution
warning: no previously-included files matching '*.so' found anywhere in distribution
zip_safe flag not set; analyzing archive contents...
google.protobuf.pyext.__pycache__.__init__.cpython-35: module references __path__
google.protobuf.__pycache__.__init__.cpython-35: module references __path__
google.__pycache__.__init__.cpython-35: module references __path__
creating /usr/local/lib/python3.5/dist-packages/protobuf-3.5.2.post1-py3.5.egg
Extracting protobuf-3.5.2.post1-py3.5.egg to /usr/local/lib/python3.5/dist-packages
Adding protobuf 3.5.2.post1 to easy-install.pth file

Installed /usr/local/lib/python3.5/dist-packages/protobuf-3.5.2.post1-py3.5.egg
Searching for pbkdf2
Reading https://pypi.python.org/simple/pbkdf2/
Downloading https://files.pythonhosted.org/packages/02/c0/6a2376ae81beb82eda645a091684c0b0becb86b972def7849ea9066e3d5e/pbkdf2-1.3.tar.gz#sha256=ac6397369f128212c43064a2b4878038dab78dab41875364554aaf2a684e6979
Best match: pbkdf2 1.3
Processing pbkdf2-1.3.tar.gz
Writing /tmp/easy_install-4bw2f2cg/pbkdf2-1.3/setup.cfg
Running pbkdf2-1.3/setup.py -q bdist_egg --dist-dir /tmp/easy_install-4bw2f2cg/pbkdf2-1.3/egg-dist-tmp-w4g89z8j
zip_safe flag not set; analyzing archive contents...
Moving pbkdf2-1.3-py3.5.egg to /usr/local/lib/python3.5/dist-packages
Adding pbkdf2 1.3 to easy-install.pth file

Installed /usr/local/lib/python3.5/dist-packages/pbkdf2-1.3-py3.5.egg
Searching for jsonrpclib-pelix
Reading https://pypi.python.org/simple/jsonrpclib-pelix/
Downloading https://files.pythonhosted.org/packages/cc/a9/8767fbdaad0e5f53803d5d0e5f5cc778dc1efbabe7f2891e4b95806246b8/jsonrpclib-pelix-0.3.1.tar.gz#sha256=5417b1508d5a50ec64f6e5b88907f111155d52607b218ff3ba9a777afb2e49e3
Best match: jsonrpclib-pelix 0.3.1
Processing jsonrpclib-pelix-0.3.1.tar.gz
Writing /tmp/easy_install-qyurejm8/jsonrpclib-pelix-0.3.1/setup.cfg
Running jsonrpclib-pelix-0.3.1/setup.py -q bdist_egg --dist-dir /tmp/easy_install-qyurejm8/jsonrpclib-pelix-0.3.1/egg-dist-tmp-9l8q0_hu
zip_safe flag not set; analyzing archive contents...
Moving jsonrpclib_pelix-0.3.1-py3.5.egg to /usr/local/lib/python3.5/dist-packages
Adding jsonrpclib-pelix 0.3.1 to easy-install.pth file

Installed /usr/local/lib/python3.5/dist-packages/jsonrpclib_pelix-0.3.1-py3.5.egg
Searching for ecdsa>=0.9
Reading https://pypi.python.org/simple/ecdsa/
Downloading https://files.pythonhosted.org/packages/f9/e5/99ebb176e47f150ac115ffeda5fedb6a3dbb3c00c74a59fd84ddf12f5857/ecdsa-0.13.tar.gz#sha256=64cf1ee26d1cde3c73c6d7d107f835fed7c6a2904aef9eac223d57ad800c43fa
Best match: ecdsa 0.13
Processing ecdsa-0.13.tar.gz
Writing /tmp/easy_install-y2ildzcc/ecdsa-0.13/setup.cfg
Running ecdsa-0.13/setup.py -q bdist_egg --dist-dir /tmp/easy_install-y2ildzcc/ecdsa-0.13/egg-dist-tmp-q_nhtaly
zip_safe flag not set; analyzing archive contents...
Moving ecdsa-0.13-py3.5.egg to /usr/local/lib/python3.5/dist-packages
Adding ecdsa 0.13 to easy-install.pth file

Installed /usr/local/lib/python3.5/dist-packages/ecdsa-0.13-py3.5.egg
Searching for dnspython
Reading https://pypi.python.org/simple/dnspython/
Downloading https://files.pythonhosted.org/packages/e4/96/a598fa35f8a625bc39fed50cdbe3fd8a52ef215ef8475c17cabade6656cb/dnspython-1.15.0.zip#sha256=40f563e1f7a7b80dc5a4e76ad75c23da53d62f1e15e6e517293b04e1f84ead7c
Best match: dnspython 1.15.0
Processing dnspython-1.15.0.zip
Writing /tmp/easy_install-irniv76e/dnspython-1.15.0/setup.cfg
Running dnspython-1.15.0/setup.py -q bdist_egg --dist-dir /tmp/easy_install-irniv76e/dnspython-1.15.0/egg-dist-tmp-vsn0kfki
warning: no files found matching 'TODO'
warning: no files found matching '*.txt' under directory 'examples'
warning: no files found matching '*.txt' under directory 'tests'
zip_safe flag not set; analyzing archive contents...
Moving dnspython-1.15.0-py3.5.egg to /usr/local/lib/python3.5/dist-packages
Adding dnspython 1.15.0 to easy-install.pth file

Installed /usr/local/lib/python3.5/dist-packages/dnspython-1.15.0-py3.5.egg
Searching for PySocks>=1.6.6
Reading https://pypi.python.org/simple/PySocks/
Downloading https://files.pythonhosted.org/packages/53/12/6bf1d764f128636cef7408e8156b7235b150ea31650d0260969215bb8e7d/PySocks-1.6.8.tar.gz#sha256=3fe52c55890a248676fd69dc9e3c4e811718b777834bcaab7a8125cf9deac672
Best match: PySocks 1.6.8
Processing PySocks-1.6.8.tar.gz
Writing /tmp/easy_install-4n8kxkam/PySocks-1.6.8/setup.cfg
Running PySocks-1.6.8/setup.py -q bdist_egg --dist-dir /tmp/easy_install-4n8kxkam/PySocks-1.6.8/egg-dist-tmp-vnq3yx9n
zip_safe flag not set; analyzing archive contents...
Moving PySocks-1.6.8-py3.5.egg to /usr/local/lib/python3.5/dist-packages
Adding PySocks 1.6.8 to easy-install.pth file

Installed /usr/local/lib/python3.5/dist-packages/PySocks-1.6.8-py3.5.egg
Searching for requests==2.12.4
Best match: requests 2.12.4
Adding requests 2.12.4 to easy-install.pth file

Using /usr/lib/python3/dist-packages
Searching for six==1.10.0
Best match: six 1.10.0
Adding six 1.10.0 to easy-install.pth file

Using /usr/lib/python3/dist-packages
Searching for setuptools==33.1.1
Best match: setuptools 33.1.1
Adding setuptools 33.1.1 to easy-install.pth file
Installing easy_install script to /usr/local/bin

Using /usr/lib/python3/dist-packages
Finished processing dependencies for Electrum==3.1.3

root@test1:/home/work/Electrum-3.1.3# python3 electrum

I'm running this in the command-line. I doubt that the VM has a GUI environment installed. I had surmised that satisfying the GUI dependencies (Qt is used for graphics) might allow electrum to then work in the command-line, but this may not be the case.

On the documentation page
docs.electrum.org/en/latest/index.html

There is a sidebar link to a section labelled "Command Line":
docs.electrum.org/en/latest/cmdline.html

Browse to this address.

Excerpt:

Command Line

Electrum has a powerful command line. This page will show you a few basic principles.

Using the inline help:

To see the list of Electrum commands, type:

electrum help

To see the documentation for a command, type:

electrum help <command>

Magic words

The arguments passed to commands may be one of the following magic words: ! ? : and -.

The exclamation mark ! is a shortcut that means 'the maximum amount available'.

Example:

electrum payto 1JuiT4dM65d8vBt8qUYamnDmAMJ4MjjxRE !

Note that the transaction fee will be computed and deducted from the amount.

[...]

Use a colon : if you want the prompted parameter to be hidden (not echoed in your terminal).

electrum importprivkey :

root@test1:/home/work/Electrum-3.1.3# electrum help

usage: electrum [-h] [-v] [-D ELECTRUM_PATH] [-P] [-w WALLET_PATH] [--testnet] [--regtest] <command> ... positional arguments: <command> gui Run GUI (default) daemon Run Daemon addrequest Create a payment request, using the first unused address of the wallet addtransaction Add a transaction to the wallet history broadcast Broadcast a transaction to the network clearrequests Remove all payment requests commands List of commands create Create a new wallet createmultisig Create multisig address createnewaddress Create a new receiving address, beyond the gap limit of the wallet decrypt Decrypt a message encrypted with a public key deserialize Deserialize a serialized transaction dumpprivkeys Deprecated encrypt Encrypt a message with a public key freeze Freeze address getaddressbalance Return the balance of any address getaddresshistory Return the transaction history of any address getaddressunspent Returns the UTXO list of any address getalias Retrieve alias getbalance Return the balance of your wallet getconfig Return a configuration variable getfeerate Return current optimal fee rate per kilobyte, according to config settings (static/dynamic) getmasterprivate Get master private key getmerkle Get Merkle branch of a transaction included in a block getmpk Get master public key getprivatekeys Get private keys of addresses getpubkeys Return the public keys for a wallet address getrequest Return a payment request getseed Get seed phrase getservers Return the list of available servers gettransaction Retrieve a transaction getunusedaddress Returns the first unused address of the wallet, or None if all addresses are used help history Wallet history importprivkey Import a private key is_synchronized return wallet synchronization status ismine Check if address is in wallet listaddresses List wallet addresses listcontacts Show your list of contacts listrequests List the payment requests you made listunspent List unspent outputs make_seed Create a seed notify Watch an address password Change wallet password payto Create a transaction paytomany Create a multi-output transaction restore Restore a wallet from text rmrequest Remove a payment request searchcontacts Search through contacts, return matching entries serialize Create a transaction from json inputs setconfig Set a configuration variable setlabel Assign a label to an item signmessage Sign a message with a key signrequest Sign payment request with an OpenAlias signtransaction Sign a transaction sweep Sweep private keys unfreeze Unfreeze address validateaddress Check that an address is valid verifymessage Verify a signature version Return the version of Electrum optional arguments: -h, --help show this help message and exit global options: -v, --verbose Show debugging information -D ELECTRUM_PATH, --dir ELECTRUM_PATH electrum directory -P, --portable Use local 'electrum_data' directory -w WALLET_PATH, --wallet WALLET_PATH wallet path --testnet Use Testnet --regtest Use Regtest Run 'electrum help <command>' to see the help for a command

Well, the

help

command works, indicating that the

electrum

program works to some degree.

Of particular note:

positional arguments:
daemon: Run Daemon
commands: List of commands
create: Create a new wallet
getaddressbalance: Return the balance of any address
getaddresshistory: Return the transaction history of any address
getbalance: Return the balance of your wallet
getfeerate: Return current optimal fee rate per kilobyte, according to config settings (static/dynamic)
getservers: Return the list of available servers
gettransaction: Retrieve a transaction
history: Wallet history
importprivkey: Import a private key
is_synchronized: return wallet synchronization status
ismine: Check if address is in wallet
listaddresses: List wallet addresses
listunspent: List unspent outputs
payto: Create a transaction
signtransaction: Sign a transaction
validateaddress: Check that an address is valid
version: Return the version of Electrum

global options:
--wallet WALLET_PATH

root@test1:/home/work/Electrum-3.1.3# electrum version
3.1.3

root@test1:/home/work/Electrum-3.1.3# electrum getservers

Daemon not running; try 'electrum daemon start'

[shut down for the day here]

[log back in]

root@test1:/home/work# electrum daemon start

starting daemon (PID 23298)

root@test1:/home/work# electrum getservers

{ "13.80.67.162": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "18.206.2.52": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "185.64.116.15": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "207.154.223.80": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "46.246.124.19": { "pruning": "-", "s": "50002", "version": "1.2" }, "4cii7ryno5j3axe4.onion": { "pruning": "-", "t": "50001", "version": "1.2" }, "74.222.1.20": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "84.197.110.145": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "88.198.43.231": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "E-X.not.fyi": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "VPS.hsmiths.com": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "arihancckjge66iv.onion": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "aspinall.io": { "pruning": "-", "s": "50002", "version": "1.2" }, "bauerjda5hnedjam.onion": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "bauerjhejlv6di7s.onion": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "bitcoin.grey.pw": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "btc.asis.io": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "btc.cihar.com": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "btc.outoftime.co": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "btc.smsys.me": { "pruning": "-", "s": "995", "version": "1.2" }, "crypto.subshell.com": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "cryptohead.de": { "pruning": "-", "s": "50002", "version": "1.2" }, "currentlane.lovebitco.in": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "daedalus.bauerj.eu": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "de.hamster.science": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "e-2.claudioboxx.com": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "e.keff.org": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "elec.luggs.co": { "pruning": "-", "s": "443", "version": "1.2" }, "electrum-server.ninja": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "electrum.achow101.com": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "electrum.anduck.net": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "electrum.be": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "electrum.chainhost.io": { "pruning": "-", "s": "50002", "version": "1.2" }, "electrum.coinucopia.io": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "electrum.cutie.ga": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "electrum.eff.ro": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "electrum.festivaldelhumor.org": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "electrum.hsmiths.com": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "electrum.leblancnet.us": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "electrum.meltingice.net": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "electrum.mindspot.org": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "electrum.nute.net": { "pruning": "-", "s": "50002", "version": "1.2" }, "electrum.petrkr.net": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "electrum.poorcoding.com": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "electrum.qtornado.com": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "electrum.taborsky.cz": { "pruning": "-", "s": "50002", "version": "1.2" }, "electrum.villocq.com": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "electrum.vom-stausee.de": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "electrum0.snel.it": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "electrum2.everynothing.net": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "electrum3.hachre.de": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "electrumx-core.1209k.com": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "electrumx.bot.nu": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "electrumx.ddns.net": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "electrumx.hopto.org": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "electrumx.kekku.li": { "pruning": "-", "s": "50002", "version": "1.2" }, "electrumx.nmdps.net": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "electrumx.soon.it": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "electrumx.westeurope.cloudapp.azure.com": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "electrumxhqdsmlu.onion": { "pruning": "-", "t": "50001", "version": "1.2" }, "elx01.knas.systems": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "elx2018.mooo.com": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "enode.duckdns.org": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "helicarrier.bauerj.eu": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "hetzner01.fischl-online.de": { "pruning": "-", "s": "50002", "version": "1.2" }, "hsmiths4fyqlw5xw.onion": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "hsmiths5mjk6uijs.onion": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "j5jfrdthqt5g25xz.onion": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "kirsche.emzy.de": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "luggscoqbymhvnkp.onion": { "pruning": "-", "t": "80", "version": "1.2" }, "ndnd.selfhost.eu": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "ndndword5lpb7eex.onion": { "pruning": "-", "t": "50001", "version": "1.2" }, "node.arihanc.com": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "node.erratic.space": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "node.ispol.sk": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "noserver4u.de": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "orannis.com": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "ozahtqwp25chjdjd.onion": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "qmebr.spdns.org": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "qtornadoklbgdyww.onion": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "quaternion.tech": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "rbx.curalle.ovh": { "pruning": "-", "s": "50002", "version": "1.2" }, "ruuxwv74pjxms3ws.onion": { "pruning": "-", "s": "10042", "t": "50001", "version": "1.2" }, "s7clinmo4cazmhul.onion": { "pruning": "-", "t": "50001", "version": "1.2" }, "shogoth.no-ip.info": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "songbird.bauerj.eu": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "spv.48.org": { "pruning": "-", "s": "50002", "t": "50003", "version": "1.2" }, "tardis.bauerj.eu": { "pruning": "-", "s": "50002", "t": "50001", "version": "1.2" }, "technetium.network": { "pruning": "-", "s": "50002", "version": "1.2" }, "v25437.1blu.de": { "pruning": "-", "s": "50002", "version": "1.2" }, "yuio.top": { "pruning": "-", "s": "50003", "t": "50001", "version": "1.2" } }

root@test1:/home/work# electrum getaddressbalance 19VdGCFG8QH3CmYXjMXd3UQCK2HdC3UodP

{ "confirmed": "0.001", "unconfirmed": "0" }

root@test1:/home/work# electrum importprivkey 5HpHagT65TZzG1PH3CSu63k8DbpvD8v17zAxKbSJNTwsxtFHvZK

Error: Wallet file not found.
Type 'electrum create' to create a new wallet, or provide a path to a wallet with the -w option

root@test1:/home/work# electrum create

Password (hit return if you do not wish to encrypt your wallet):
Your wallet generation seed is:
"used depart cupboard fog wall organ above skill local multiply ketchup fatigue"
Please keep it in a safe place; if you lose it, you will not be able to restore your wallet.
Wallet saved in '/root/.electrum/wallets/default_wallet'

root@test1:/home/work# electrum help create

usage: electrum create [-h] [-v] [-D ELECTRUM_PATH] [-P] [-w WALLET_PATH] [--testnet] [--regtest] [--segwit] Create a new wallet optional arguments: -h, --help show this help message and exit --segwit Create segwit seed global options: -v, --verbose Show debugging information -D ELECTRUM_PATH, --dir ELECTRUM_PATH electrum directory -P, --portable Use local 'electrum_data' directory -w WALLET_PATH, --wallet WALLET_PATH wallet path --testnet Use Testnet --regtest Use Regtest

root@test1:/home/work# electrum listaddresses

Wallet "default_wallet" is not loaded. Use "electrum daemon load_wallet"

root@test1:/home/work# electrum daemon load_wallet

true

root@test1:/home/work# electrum listaddresses

[ "12v3KGDdZFrsVbXSHV8WfQBa2ceeaCqEqN", "15zPHEbpjtQA6EDHmRjRU1KsreQT2wo7S2", "1P6ZmdoNCXCQNRKcxgRLA67YQLtks2USa5", "12oeArvgeJJmCWPb4Toa76TxSABrggSuto", "1AVEutvq4i59eC9w8LvT7jwMnoErui2MjC", "1VLJKXBbJvM5pbHjNtvDEDbUwokSKvRFS", "1MDzYKAQ9ASeLiv8HcMXqmBdnp3DUKsQb8", "1KatjR2ptVjeNkizxC1q9JiVhWoEqYEhVY", "1PMESnfpJmmCzBEKmw6UGUYodftHxYepR7", "14Hd4ostxsS1PpbuAYvuw8Dcr9MtHswUhp", "1GBYUzExVJVm3NToExXkKxiMDAVECjjyHp", "1Jt7CGoHzmiXnCrGbq5Uz2Y1EyWvyDiCUx", "1HnUp2pqRkKjoLrKjLnMsrTyFfVNHmNuu7", "18TGjwyu6Fyui3XQZYv1XKC5nDeWvneUci", "1ArSCH9sgZnGVQfvUHyD8LzJqwSeJybG6J", "16RqgcGYE5twgwXEEmsYejmPkJeUosbYxc", "145HzJNxLxdmvrbAYSNmrX8aj4N1z44Sxn", "1KG3Lvzd6hDjVagH4nDuTMFLMsPrH9svzZ", "1BNvtqXYZajB31EJ9A6bE8KTvfTjZfPrHA", "1ArbM5VzoyxHBsAeMNJkhg7xbJyQRnmFWQ", "1FjD5c5PHqXq6LqnVCg6kj9pjfMrNeFPZU", "1FgHN9VzfJ4ig5UMgeC2J5xMDhMZeUSJUZ", "1QCxQJPMP3S8Bsind82jVNBY2kCBnMEnQz", "1Q8dLuE9gMcoQoZVDvbYexa1jdrFt9avvM", "1EWENrW2ERhoAtwcsqGRDdjEx3G4FYiob8", "19TWfbHVnGTLt8L4D9QDgvPz3gBiQ3SN8V" ]

Excerpt from:
docs.electrum.org/en/latest/cmdline.html

The following command will export the private keys of all wallet addresses that hold some bitcoins:

electrum listaddresses --funded | electrum getprivatekeys -

root@test1:/home/work# electrum listaddresses | electrum getprivatekeys -

WARNING: ALL your private keys are secret. Exposing a single private key can compromise your entire wallet! In particular, DO NOT use 'redeem private key' services proposed by third parties. [ "p2pkh:L3s6aAGnyEuckzK5EXNJvaPXPZhsRZLtiki6W8Uoso4DkkAAsfbb", "p2pkh:L3tGrd4a4NyHAJHGHKt9cSwLomLyE3HmxHTKgUciY4uWebK1ycn4", "p2pkh:L5BwXTdpLKLK3UPv5sfvLRPRJ1dGUSZ8QWdhvYZoyRJCwVsV5UR2", "p2pkh:KxUU5sv2EpLU2bFwYkwr2w2WQD2ModZ6eGPs6SGZJdMGYmQY8kkG", "p2pkh:L5UrSGfWXGGFP4Z9wH7h8xcmWcNU3jYL8unUqFvhxBJyRhyc7RKM", "p2pkh:L1soi4Vyvh3KTPAESxRXXiDZMp7TNw8aWGo4FhpHzL8xsQRqaRez", "p2pkh:L23A5UvDn3gJAd54UknPDBcWgF4nYdsMemmcPrhp8qC6R2S1HcmP", "p2pkh:L2Wpxw2HXKGmfhdn2GSi77NsBe3kAWaNqekGbAL3UqHMXC8JSJiM", "p2pkh:KyxjvpLxQWGnpRuGZ2BMuAoomcAXSg2wfJbkNk2ghTggF6KtgXMt", "p2pkh:Kzy6WrDcZZemhoA1FN8DiGkedj5hsDdpssyRejN3PYmKPqkFE63t", "p2pkh:L35HvtwZByVpExEGS3UPTDiiVuyovbE4UYJduWxToQ2kYvBTaSZm", "p2pkh:L4F2ttffdNXZqNFBGsrWQLu5sUuK1uqeWJidTZX8bSCowvqAEbLU", "p2pkh:Kwd2BC4oSu8pHK4iFQwFsEcfJe6xd7v7ptupthjiGwddFTTdWWgF", "p2pkh:Kzb72mQoN4hR4aB8fSB68Xmzs7FJWj2A2gVPVSCsjToqJZBB1Qpm", "p2pkh:KzzGQYGYFwGYE8ZqUBs7XntztULAzSKwuvPhX62NxovTcjTf39z4", "p2pkh:KwWs3a8bUateseT2VrduUYAwSDeuoGyENSUHjrPbFf3Uzyxjf4jF", "p2pkh:L5H7ySVsDx88nzUtgVWVgDgFh3ZDXton1mit87e4tPKKefggiBD2", "p2pkh:L1q6mw273UHPxhyc5Sx47tDb11uDN2oCA5oNPcWZ6vUohTfER2XY", "p2pkh:L5BardHmxWA46dkKokgEVmxrUN2XRfRKoyZksiebuFB9hNwfbtRJ", "p2pkh:L5FWaseyi9r12ZR9bu3QinFQCU3ixDRhRSVhZQZV7uabm74ZU3cb", "p2pkh:Ky1qAd2ApGigq17oNfbJ16AY1hVC648SMtJTVtAZzwqDoNLZFPjq", "p2pkh:Kx73JwQV1DMZadjswYpPhvEymUUGrgWxnQvRhSRZfs6q6HRfoZzM", "p2pkh:L3mkGGKKWQPcLM7dZu6SoPXeTd3U8LdZNL1EVTUN3FvddpTN5psS", "p2pkh:L2kit8bv6pUmyi6rUpkVNHoUr2AQgZTmrV5hrVdVHrdUmsfbeNkh", "p2pkh:L17yHdjhjcRhNG28EXdpeJvsDkVsojMqxYd7R7SYzFJGEig7xVCH", "p2pkh:L11RhojB2TjpiBrR8D9KmjE4swsKQSBJRrapAj6AdB217cL2jfJv" ]

root@test1:/home/work# electrum importprivkey 5HpHagT65TZzG1PH3CSu63k8DbpvD8v17zAxKbSJNTwsxtFHvZK

Error: This type of wallet cannot import private keys. Try to create a new wallet with that key.

root@test1:/home/work# electrum create 5HpHagT65TZzG1PH3CSu63k8DbpvD8v17zAxKbSJNTwsxtFHvZK

usage: electrum [-h] [-v] [-D ELECTRUM_PATH] [-P] [-w WALLET_PATH] [--testnet] [--regtest] <command> ... electrum: error: unrecognized arguments: 5HpHagT65TZzG1PH3CSu63k8DbpvD8v17zAxKbSJNTwsxtFHvZK

Hm. After some searching and reading, I'm fairly sure that the create-wallet-without-seed option can only be accessed from the Electrum GUI.

However, if I can sweep from this private key to the seed wallet, that will be sufficient to conclude that the private key is valid and that the bitcoin can be retrieved from the corresponding public address.

root@test1:/home/work# electrum getfeerate

2227

Presumably the fee rate is in satoshis.
I sent 0.001 bitcoin to the address, which is 0.001*(10**8) = 10000 satoshis, which is enough to pay the transaction fee for sweeping.

root@test1:/home/work# electrum sweep 5HpHagT65TZzG1PH3CSu63k8DbpvD8v17zAxKbSJNTwsxtFHvZK

usage: electrum sweep [-h] [-v] [-D ELECTRUM_PATH] [-P] [-w WALLET_PATH] [--testnet] [--regtest] [-f FEE] [--nocheck] [--imax IMAX] privkey destination electrum sweep: error: the following arguments are required: destination

Hm. A destination address is required. Perhaps this destination doesn't have to be an address in the Electrum wallet, and could instead be my LocalBitcoins receiving address. This would allow me to spend one transaction fee rather than two.

On the "Receive bitcoins" tab in my LocalBitcoins account, the address listed is:
1GgW5oTD3nFnEsGqXUdu61gksi8ohzXmaN

The page notes that:
- Current deposit fee for incoming transactions: 0.00015 BTC
- Receiving Bitcoin usually takes 30 minutes, however it can take up to 14 days or longer. An incoming transaction needs to receive 3 Bitcoin network confirmations to appear in your wallet.
- To protect your privacy, we provide a new bitcoin address for each transfer. This prevents someone from tracking all the payments you receive by looking at the blockchain. Note that any address provided here will continue to be linked to your LocalBitcoins account.

So, my current receiving address is only temporary.

I note that 0.001 bitcoin is enough to pay both the current Bitcoin network transaction fee of 0.00002227 and the LocalBitcoins deposit fee of 0.00015.

root@test1:/home/work# electrum sweep 5HpHagT65TZzG1PH3CSu63k8DbpvD8v17zAxKbSJNTwsxtFHvZK 1GgW5oTD3nFnEsGqXUdu61gksi8ohzXmaN

{ "complete": true, "final": false, "hex": "0100000001f2779f994f23374f6742733c87d0fd01e812009af19710ece0b31c1eeedf11e6020000008a4730440220678dc3a5ded95dd3e535270ef9dff67a7f15426463c52f832c4d22e4afa07bdd02202199f2f83cb63e07195ca8495527d4d2c866747e81506909bb43068f3e56f1390141043cd69b03d4bbbdc07450a36de99e792aaaf00298076d0daa761450156bb9c1b75a72839ce8c498f55fbb69312a661d3572c250e26a0189ae068ef50abc68d3e7fdffffff01e0840100000000001976a914ac0262e76a76ee2a0055ba1c90fdedc7ab6cfab688ac62050800" }

This hex data is presumably the transaction that has been signed and broadcast.

root@test1:/home/work# electrum getaddressbalance 1GgW5oTD3nFnEsGqXUdu61gksi8ohzXmaN

{ "confirmed": "0", "unconfirmed": "0" }

root@test1:/home/work# electrum help sweep

usage: electrum sweep [-h] [-v] [-D ELECTRUM_PATH] [-P] [-w WALLET_PATH] [--testnet] [--regtest] [-f FEE] [--nocheck] [--imax IMAX] privkey destination Sweep private keys. Returns a transaction that spends UTXOs from privkey to a destination address. The transaction is not broadcasted. positional arguments: privkey Private key. Type '?' to get a prompt. destination Bitcoin address, contact or alias optional arguments: -h, --help show this help message and exit -f FEE, --fee FEE Transaction fee (in BTC) --nocheck Do not verify aliases --imax IMAX Maximum number of inputs global options: -v, --verbose Show debugging information -D ELECTRUM_PATH, --dir ELECTRUM_PATH electrum directory -P, --portable Use local 'electrum_data' directory -w WALLET_PATH, --wallet WALLET_PATH wallet path --testnet Use Testnet --regtest Use Regtest

Key section: "Sweep private keys. Returns a transaction that spends UTXOs from privkey to a destination address. The transaction is not broadcasted."

I think the transaction is probably signed.

In the output of

electrum help

, I see this command:

broadcast

("Broadcast a transaction to the network").

root@test1:/home/work# electrum broadcast 0100000001f2779f994f23374f6742733c87d0fd01e812009af19710ece0b31c1eeedf11e6020000008a4730440220678dc3a5ded95dd3e535270ef9dff67a7f15426463c52f832c4d22e4afa07bdd02202199f2f83cb63e07195ca8495527d4d2c866747e81506909bb43068f3e56f1390141043cd69b03d4bbbdc07450a36de99e792aaaf00298076d0daa761450156bb9c1b75a72839ce8c498f55fbb69312a661d3572c250e26a0189ae068ef50abc68d3e7fdffffff01e0840100000000001976a914ac0262e76a76ee2a0055ba1c90fdedc7ab6cfab688ac62050800

[ true, "55cef237815986b3bebd602154c01592710f77213f7c9718b991b4b8e19b9954" ]

[approximately 1 minute later]

root@test1:/home/work# electrum getaddressbalance 1GgW5oTD3nFnEsGqXUdu61gksi8ohzXmaN

{ "confirmed": "0", "unconfirmed": "0.00099552" }

[approximately 28 minutes later]

root@test1:/home/work# electrum getaddressbalance 1GgW5oTD3nFnEsGqXUdu61gksi8ohzXmaN

{ "confirmed": "0.00099552", "unconfirmed": "0" }

Browse to blockchain.info and search for
1GgW5oTD3nFnEsGqXUdu61gksi8ohzXmaN

blockchain.info/address/1GgW5oTD3nFnEsGqXUdu61gksi8ohzXmaN

1 transaction is listed, with 2 confirmations.
txid:
55cef237815986b3bebd602154c01592710f77213f7c9718b991b4b8e19b9954

A useful feature for an Electrum-like system would be a command-line option to check number-of-confirmations for a particular transactions.

34 mins later:
Refresh the blockchain.info page. 3 confirmations.

8 mins later:
4 confirmations.

I'll accept 4 for the moment, rather than 6.

Browse to the Transactions tab in my LocalBitcoins account.

Latest transaction:
- Date = 06/02/2018 23:07
- Received BTC = 0.00084552
- Description = Deposit to 1GgW5o......
- Deposit Fee BTC = 0.00015000

Excellent. I have succeeded in:
- creating a private key
- generating the corresponding Bitcoin address
- sending bitcoin to this address
- generating the private key in WIF form
- retrieving bitcoin from this address using the private key in WIF form
-- this can be achieved by creating and broadcasting a signed transaction

Next: Shut down the electrum daemon.

root@test1:/home/work# electrum daemon help

usage: electrum daemon [-h] [-1] [-s SERVER] [-p PROXY] [-v] [-D ELECTRUM_PATH] [-P] [-w WALLET_PATH] [--testnet] [--regtest] [{start,status,stop,load_wallet,close_wallet}] electrum daemon: error: argument subcommand: invalid choice: 'help' (choose from 'start', 'status', 'stop', 'load_wallet', 'close_wallet')

root@test1:/home/work# electrum daemon close_wallet

true

root@test1:/home/work# electrum daemon status

{ "auto_connect": true, "blockchain_height": 525672, "connected": true, "current_wallet": "/root/.electrum/wallets/default_wallet", "fee_per_kb": 1576, "path": "/root/.electrum", "server": "electrumx.westeurope.cloudapp.azure.com", "server_height": 525672, "spv_nodes": 10, "version": "3.1.3", "wallets": {} }

root@test1:/home/work# electrum daemon stop

Daemon stopped

Next: Copy the Electrum-3.1.3 tarball and the signature to my work computer.

aineko:~ stjohnpiano$ sftp root@167.99.188.209

Connecting to 167.99.188.209...
sftp> lcd Downloads
sftp> ls
sftp> pwd
Remote working directory: /root
sftp> cd /home/work
sftp> ls -1
Electrum-3.1.3
Electrum-3.1.3.tar.gz
Electrum-3.1.3.tar.gz.asc
thomasv.public_key

sftp> get Electrum-3.1.3.tar.gz* Fetching /home/work/Electrum-3.1.3.tar.gz to Electrum-3.1.3.tar.gz /home/work/Electrum-3.1.3.tar.gz 100% 2740KB 913.5KB/s 00:03 Fetching /home/work/Electrum-3.1.3.tar.gz.asc to Electrum-3.1.3.tar.gz.asc /home/work/Electrum-3.1.3.tar.gz.asc 100% 801 0.8KB/s 00:00

sftp> exit

For both files, decapitalise the first letter "E" in the filename. Add them as assets to this article.

Refresh
blockchain.info/address/1GgW5oTD3nFnEsGqXUdu61gksi8ohzXmaN

I now see 6 confirmations.

Hm. I'd like to automate the process that I used to generate a Bitcoin address.

[development occurs here]

generate_bitcoin_address.py

#!/opt/local/bin/python

import ecdsa

from binascii import hexlify, unhexlify

from pypy_sha256 import sha256

from bjorn_edstrom_ripemd160 import RIPEMD160

def main():

	# input

	private_key_bytes = "hello_world"

	print ""

	print "- INPUT: private_key_bytes: %s" % private_key_bytes

	private_key_hex = hexlify(private_key_bytes)

	print "- private_key_hex: %s" % private_key_hex

	# format private key as 32 bytes.

	n = len(private_key_hex) / 2

	m = 32 - n

	if m > 0:

		# add leading zero bytes to extend private_key_hex to 32 bytes

		private_key_hex2 = m * "00" + private_key_hex

	print "- 32-byte private_key_hex: %s" % private_key_hex2

	check_if_private_key_is_in_secp256k1_input_domain(private_key_hex2)

	print "- private key lies within input domain of secp256k1 elliptic curve."

	# convert the private key to WIF format.

	# add "80" byte at the front.

	private_key_hex3 = "80" + private_key_hex2

	private_key_WIF = base58check(private_key_hex3)

	print "- private_key_WIF: %s" % private_key_WIF

	# use ECDSA library to derive the public key from the private key

	private_key_int = int(private_key_hex2, 16)

	signing_key = ecdsa.SigningKey.from_secret_exponent(private_key_int, curve=ecdsa.SECP256k1)

	verifying_key = signing_key.verifying_key

	verifying_key_bytes = verifying_key.to_string()

	verifying_key_hex = hexlify(verifying_key_bytes)

	# note: verifying_key.to_string() returns: x_str + y_str

	# add identification byte to verifying key ("04" for "uncompressed") to get an uncompressed Bitcoin public key

	public_key_hex = "04" + verifying_key_hex

	print "- public_key_hex: %s" % public_key_hex

	# hash the public key twice: first with SHA256 and then with RIPEMD-160.

	public_key_bytes = unhexlify(public_key_hex)

	digest = sha256(public_key_bytes).digest()

	digest2 = RIPEMD160(digest).digest()

	public_key_hash_hex = hexlify(digest2)

	# add version byte to public key hash ("00" for "main Bitcoin network").

	public_key_hash_hex2 = "00" + public_key_hash_hex

	# convert the public key hash to Base58Check format.

	address = base58check(public_key_hash_hex2)

	print "- Bitcoin address: %s" % address

	print ""

def base58check(input_hex):

	input_bytes = unhexlify(input_hex)

	# calculate checksum

	digest = sha256(input_bytes).digest()

	digest2 = sha256(digest).digest()

	digest_hex = hexlify(digest2)

	checksum_hex = digest_hex[:8] # first 4 bytes

	item_hex = input_hex + checksum_hex

	item_base58_str = convert_hex_to_base58(item_hex)

	n = count_leading_zero_bytes(input_hex)

	item_base58_str = n * '1' + item_base58_str

	return item_base58_str

def count_leading_zero_bytes(input_hex):

	count = 0

	for i in range(0, len(input_hex), 2):

		byte = input_hex[i:i+2]

		if byte == '00':

			count += 1

		else:

			break

	return count

def convert_hex_to_base58(input_hex):

	input_int = int(input_hex, 16)

	# the string base58_symbols can accessed as a 0-indexed list of characters.

	base58_symbols = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"

	output_str = ''

	item_int = input_int

	while item_int > 0:

		item_int, remainder = divmod(item_int, 58)

		# use remainder as index for accessing the corresponding base58 symbol.

		output_str += base58_symbols[remainder]

	output_str = ''.join(reversed(output_str))

	return output_str

def check_if_private_key_is_in_secp256k1_input_domain(private_key_hex):

	private_key_int = int(private_key_hex, 16)

	max_hex = "FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFE BAAEDCE6 AF48A03B BFD25E8C D0364140"

	max_hex = max_hex.replace(' ','')

	max_int = int(max_hex, 16)

	min_int = 1

	if (min_int <= private_key_int <= max_int):

		return 0

	if min_int > private_key_int:

		stop("\nERROR: The private key (int value = %d) is less than the minimum allowed integer value (int value = %d).\n" % (private_key_int, min_int))

	if private_key_int > max_int:

		stop("\nERROR: The private key (int value = %d) is greater than the maximum allowed integer value (int value = %d).\n" % (private_key_int, max_int))

	return 1

def stop(message):

	# raise an Exception to get a traceback.

	raise Exception("ERROR: %s\n" % message)

if __name__ == '__main__': main()

aineko:work stjohnpiano$ chmod 700 generate_bitcoin_address.py

aineko:work stjohnpiano$ ./generate_bitcoin_address.py

Let's confirm that these values are the same as those found earlier.

Earlier values:

Private key: hello_world
Private key in hex: 68656c6c6f5f776f726c64
Public key in hex:
043cd69b03d4bbbdc07450a36de99e792aaaf00298076d0daa761450156bb9c1b75a72839ce8c498f55fbb69312a661d3572c250e26a0189ae068ef50abc68d3e7
Bitcoin address: 19VdGCFG8QH3CmYXjMXd3UQCK2HdC3UodP
Private key in WIF form:
5HpHagT65TZzG1PH3CSu63k8DbpvD8v17zAxKbSJNTwsxtFHvZK

The private keys in raw bytes are both "hello_world".

Let 's' signify 'string'.
Using the suffix '1' for the value found earlier and the suffix '2' for the newly generated value:

[private_key_hex]

aineko:work stjohnpiano$ s1="68656c6c6f5f776f726c64"

aineko:work stjohnpiano$ s2="68656c6c6f5f776f726c64"

aineko:work stjohnpiano$ [[ "$s1" = "$s2" ]] && echo equal || echo not-equal

equal

[Private key in WIF form]

aineko:work stjohnpiano$ s1="5HpHagT65TZzG1PH3CSu63k8DbpvD8v17zAxKbSJNTwsxtFHvZK"

aineko:work stjohnpiano$ s2="5HpHagT65TZzG1PH3CSu63k8DbpvD8v17zAxKbSJNTwsxtFHvZK"

aineko:work stjohnpiano$ [[ "$s1" = "$s2" ]] && echo equal || echo not-equal

equal

[public_key_hex]

aineko:work stjohnpiano$ s1="043cd69b03d4bbbdc07450a36de99e792aaaf00298076d0daa761450156bb9c1b75a72839ce8c498f55fbb69312a661d3572c250e26a0189ae068ef50abc68d3e7"

aineko:work stjohnpiano$ s2="043cd69b03d4bbbdc07450a36de99e792aaaf00298076d0daa761450156bb9c1b75a72839ce8c498f55fbb69312a661d3572c250e26a0189ae068ef50abc68d3e7"

aineko:work stjohnpiano$ [[ "$s1" = "$s2" ]] && echo equal || echo not-equal

equal

[Bitcoin address]

aineko:work stjohnpiano$ s1="19VdGCFG8QH3CmYXjMXd3UQCK2HdC3UodP"

aineko:work stjohnpiano$ s2="19VdGCFG8QH3CmYXjMXd3UQCK2HdC3UodP"

aineko:work stjohnpiano$ [[ "$s1" = "$s2" ]] && echo equal || echo not-equal

equal

Good. Generated values match those found earlier.

There's a loose end: How to ssh into the droplet VM using the domain name instead of the IP address.

aineko:~ stjohnpiano$ ssh root@edgecase-test.net

ssh: Could not resolve hostname edgecase-test.net: nodename nor servname provided, or not known

I forgot to create an A record that would link the domain edgecase-test.net to the IP address 167.99.188.209.

Log in to Digital Ocean.

In Dashboard / Resources / Domains, click edgecase-test.net. This leads to Networking / Create new record / A.

There are three nameserver entries already.

New record:
- Hostname = @ (this signifies the "edgecase-test.net" base domain)
- Will direct to = [select droplet "test1" at IP address 167.99.188.209 from drop-down menu]
- TTL (seconds) = 3600
Click Create Record.

time: 1:10 pm

aineko:~ stjohnpiano$ ssh root@edgecase-test.net

ssh: Could not resolve hostname edgecase-test.net: nodename nor servname provided, or not known

Excerpt from:
www.digitalocean.com/community/questions/how-long-to-update-a-records

Q:

How long to update A Records?
April 22, 2015
moshe

I already have my domain pointed to Digital Ocean DNS and now I want to change the A record between one droplet and another.

After I make the change on Digital Ocean DNS about how long will it take to update so that when I go to mydomain.com it will point to updated IP address?

A:

April 22, 2015
ryanpq

If your domain is already pointed to the DigitalOcean nameservers the change will usually be near instantaneous but with caching on other servers that have the record it may take up to 30-45 minutes for the change to be reflected everywhere.

time: 2:43 pm

so, 1 hour and 33 minutes later.

aineko:~ stjohnpiano$ ssh root@edgecase-test.net

The authenticity of host 'edgecase-test.net (167.99.188.209)' can't be established.
RSA key fingerprint is b2:b5:5d:21:cd:fc:84:04:15:bc:14:d4:3a:1e:d2:9f.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added 'edgecase-test.net' (RSA) to the list of known hosts.
Linux test1 4.9.0-6-amd64 #1 SMP Debian 4.9.88-1+deb9u1 (2018-05-07) x86_64

The programs included with the Debian GNU/Linux system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.

Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
permitted by applicable law.
Last login: Sat Jun 2 20:05:51 2018 from 82.11.184.184

root@test1:~# pwd

/root

root@test1:~# ls -1 /home/work

Electrum-3.1.3
Electrum-3.1.3.tar.gz
Electrum-3.1.3.tar.gz.asc
thomasv.public_key

root@test1:~# exit

logout
Connection to edgecase-test.net closed.

Cool.

In the Digital Ocean web management application, delete the "test1" droplet VM and delete the A record for the domain edgecase-test.net.

Note: Digital Ocean uses the term "destroy" instead of "delete" for a droplet.

[start of notes]

Changes from the original text:

- I have not always preserved the format of any excerpts from webpages on other sites (e.g. not preserving the original bold/italic styles, changing the list structures, not preserving hyperlinks).

- I have not always preserved the format of any excerpts from PDF files (e.g. not preserving superscript or subscript, replacing stylised characters with basic ASCII characters or descriptions (e.g. "triple_bar", "element_of")).

- I have not always preserved the format of any computer output (e.g. from running bash commands). Examples: Setting input lines in bold text, adding/removing newlines in order to make a sequence of commands easier to read, using hyphens for lists and sublists instead of indentation, breaking wide tables into consecutive sections.

[end of notes]