def test_bip39(self):
     for [seed, exp_mnemonic, hex_seed, xprv] in VECTORS:
         act_mnemonic = mnemonic_from_bytes(unhexlify(seed))
         act_xkey = HDKey.from_seed(
             mnemonic_to_seed(act_mnemonic, password="******"))
         self.assertEqual(act_mnemonic, exp_mnemonic)
         self.assertTrue(mnemonic_is_valid(act_mnemonic))
         self.assertEqual(
             hexlify(mnemonic_to_bytes(act_mnemonic)).decode(), seed)
         self.assertEqual(act_xkey.to_base58(), xprv)
Exemple #2
0
 def set_mnemonic(self, mnemonic=None, password=""):
     """Load mnemonic and password and create root key"""
     if mnemonic is not None:
         self.mnemonic = mnemonic.strip()
         if not bip39.mnemonic_is_valid(self.mnemonic):
             raise KeyStoreError("Invalid mnemonic")
     seed = bip39.mnemonic_to_seed(self.mnemonic, password)
     self.root = bip32.HDKey.from_seed(seed)
     self.fingerprint = self.root.child(0).fingerprint
     # id key to sign and encrypt wallet files
     # stored on untrusted external chip
     self.idkey = self.root.child(0x1D, hardened=True).key.serialize()
 def handle_next_recovery_phrase_word_button(self, obj, event):
     if event == lv.EVENT.RELEASED and obj.get_state(
     ) != BUTTON_DISABLED_STATE:
         self.recovery_phrase.append(self.recovery_phrase_input.get_text())
         if len(self.recovery_phrase) == self.recovery_phrase_target_length:
             recovery_phrase = " ".join(self.recovery_phrase)
             if bip39.mnemonic_is_valid(recovery_phrase):
                 self.show_password_input()
             else:
                 self.show_recovery_failed()
         else:
             self.show_phrase_input()
Exemple #4
0
 async def process_host_command(self, stream, show_fn):
     # reads prefix from the stream (until first space)
     prefix = self.get_prefix(stream)
     if prefix not in self.prefixes:
         # WTF? It's not our data...
         raise AppError("Prefix is not valid: %s" % prefix.decode())
     mnemonic = stream.read().strip().decode()
     if not bip39.mnemonic_is_valid(mnemonic):
         raise AppError("Invalid mnemonic!")
     scr = Prompt("Load this mnemonic to memory?", "Mnemonic:")
     table = MnemonicTable(scr)
     table.align(scr.message, lv.ALIGN.OUT_BOTTOM_MID, 0, 30)
     table.set_mnemonic(mnemonic)
     if await show_fn(scr):
         self.keystore.set_mnemonic(mnemonic)
     return None
Exemple #5
0
 def set_mnemonic(self, mnemonic=None, password=""):
     if mnemonic == self.mnemonic and password != "":
         # probably checking mnemonic after saving
         self.show_loader()
     else:
         self.show_loader(title="Generating keys...")
     """Load mnemonic and password and create root key"""
     if mnemonic is not None:
         self.mnemonic = mnemonic.strip()
         if not bip39.mnemonic_is_valid(self.mnemonic):
             raise KeyStoreError("Invalid mnemonic")
     seed = bip39.mnemonic_to_seed(self.mnemonic, password)
     self.root = bip32.HDKey.from_seed(seed)
     self.fingerprint = self.root.child(0).fingerprint
     # id key to sign and encrypt wallet files
     # stored on untrusted external chip
     self.idkey = self.root.child(0x1D, hardened=True).key.serialize()
 def test_invalid_checksum(self):
     words = (
         "ivory canyon lend simple system regret test cool clip foam answer abandon"
     )
     self.assertFalse(mnemonic_is_valid(words))
 def test_invalid_word(self):
     words = "fljsafk minute glow ride mask ceiling old limb rookie discover cotton biology"
     self.assertFalse(mnemonic_is_valid(words))
 def test_invalid_length(self):
     words = "panel trumpet seek bridge income piano history car flower aim loan accident embark canoe"
     self.assertFalse(mnemonic_is_valid(words))
Exemple #9
0
####################################
#                                  #
#      key generation - part 2     #
#                                  #
####################################

################# BIP-39 #####################

phrase = bip39.mnemonic_from_bytes(entropy)
print("Your recovery phrase:\n%s\n" % phrase)

# uncomment this line to make invalid mnemonic:
# phrase += " satoshi"

# you can check if recovery phrase is valid or not:
if not bip39.mnemonic_is_valid(phrase):
    raise ValueError("Meh... Typo in the recovery?")

# convert mnemonic and password to bip-32 seed
seed = bip39.mnemonic_to_seed(phrase, password="******")
print("Seed:", hexlify(seed).decode())

################# BIP-32 #####################

# we will use signet:
network = NETWORKS["signet"]

# create HDKey from 64-byte seed
root_key = bip32.HDKey.from_seed(seed)
# generate an account child key:
# purpose: 84h - BIP-84
Exemple #10
0
from bitcoin import bip32, bip39, script
# NETWORKS contains all constants for HD keys and addresses
from bitcoin.networks import NETWORKS
# we will use testnet:
network = NETWORKS["test"]

entropy = b'\x64\xd3\xe4\xa0\xa3\x87\xe2\x80\x21\xdf\x55\xa5\x1d\x45\x4d\xcf'

recovery_phrase = bip39.mnemonic_from_bytes(entropy)
print("Your recovery phrase:\n%s\n" % recovery_phrase)

# uncomment this line to make invalid mnemonic:
# recovery_phrase += " satoshi"

# you can check if recovery phrase is valid or not:
if not bip39.mnemonic_is_valid(recovery_phrase):
    raise ValueError("Meh... Typo in the recovery?")

# convert mnemonic and password to bip-32 seed
seed = bip39.mnemonic_to_seed(recovery_phrase, password="******")
print("Seed:", hexlify(seed).decode("ascii"))

# create HDKey from 64-byte seed
root_key = bip32.HDKey.from_seed(seed)
# generate an account child key:
# purpose: 84h - BIP-84
# coin type: 1h - Testnet
# account: 0h - first account
account = root_key.derive("m/84h/1h/0h")
# convert HD private key to HD public key
account_pub = account.to_public()