def f(choices_layout):
self.seed_type = seed_type_values[choices_layout.selected_index()]
self.seed_status.setText('')
if self.seed_type == 'bip39':
if self.opt_button:
self.opt_button.setVisible(False)
self.lang_cb.setVisible(True)
k = 'bip39_'+self.lang
if k not in self.cached_seed_phrases:
seed = mnemonic.Mnemonic(self.lang).make_bip39_seed()
self.cached_seed_phrases[k] = seed
else:
seed = self.cached_seed_phrases[k]
self.seed_warning.setText(SEED_WARNING_1(seed))
self.seed_e.setText(seed)
self.seed_type = 'bip39'
else:
if self.opt_button:
self.opt_button.setVisible(True)
self.lang_cb.setVisible(False)
k = 'electrum'
if k not in self.cached_seed_phrases:
seed = mnemonic.Mnemonic('en').make_seed(seed_type=self.electrum_seed_type)
self.cached_seed_phrases[k] = seed
else:
seed = self.cached_seed_phrases[k]
self.seed_warning.setText(SEED_WARNING_1(seed))
self.seed_e.setText(seed)
self.seed_type = 'electrum'
def main():
arg_parser = argparse.ArgumentParser()
arg_parser.add_argument("n", nargs="?", default=None)
args = arg_parser.parse_args()
if args.n:
n = int(args.n)
else:
n = int(input_with_message("How many words do you want to type: "))
assert (1 < n)
order = list(range(n))
prng = coinchooser.PRNG(os.urandom(100))
prng.shuffle(order)
wordlist = mnemonic.Mnemonic().wordlist
words = [""] * n
for i in range(n):
valid = False
while not valid:
word = input_with_message("Type word {0}: ".format(order[i] + 1))
if word in wordlist:
valid = True
else:
print("INVALID WORD, TYPE AGAIN", file=sys.stderr)
words[order[i]] = word
print(" ".join(words))
def on_change():
i = self.lang_cb.currentIndex()
l = self.languages[i][0]
k = 'bip39_' + l
if k not in self.cached_seed_phrases:
seed = mnemonic.Mnemonic(l).make_bip39_seed()
self.cached_seed_phrases[k] = seed
else:
seed = self.cached_seed_phrases[k]
self.seed_warning.setText(SEED_WARNING_1(seed))
self.seed_e.setText(seed)
self.lang = l
def test_mnemonic_to_seed(self):
for test_name, test in SEED_TEST_CASES.items():
if test.words_hex is not None:
self.assertEqual(test.words_hex, bh2u(test.words.encode('utf8')), msg=test_name)
self.assertTrue(is_new_seed(test.words, prefix=test.seed_version), msg=test_name)
m = mnemonic.Mnemonic(lang=test.lang)
if test.entropy is not None:
self.assertEqual(test.entropy, m.mnemonic_decode(test.words), msg=test_name)
if test.passphrase_hex is not None:
self.assertEqual(test.passphrase_hex, bh2u(test.passphrase.encode('utf8')), msg=test_name)
seed = mnemonic.Mnemonic.mnemonic_to_seed(mnemonic=test.words, passphrase=test.passphrase)
self.assertEqual(test.bip32_seed, bh2u(seed), msg=test_name)
def main():
words = read_and_validate()
wordlist = mnemonic.Mnemonic().wordlist
print("Good last words:")
ok_words = []
for last in wordlist:
(checksum_ok, wordlist_ok) = keystore.bip39_is_checksum_valid(
" ".join(words + [last]))
assert wordlist_ok
if checksum_ok:
print(last)
ok_words.append(last)
prng = coinchooser.PRNG(os.urandom(100))
print("\nA random choice would be:")
print(prng.choice(ok_words))
from bitcoin import *
from electrum import mnemonic
import logging
import sys
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)
m = mnemonic.Mnemonic()
if __name__ == '__main__':
try:
seed = m.make_seed()
logger.debug(seed)
priv = sha256(seed)
logger.debug(priv)
pub = privtopub(priv)
logger.debug(pub)
addr = pubtoaddr(pub)
logger.debug(addr)
addr_priv = privtoaddr(priv)
logger.debug(addr_priv)
except Exception as e:
logger.exception(e)
async def co_gen_seed(seed_type, language):
self.generatedSeed = mnemonic.Mnemonic(language).make_seed(
seed_type=seed_type)
self._logger.debug('seed generated')
self.generatedSeedChanged.emit()
