Conversions: mnemo => seed => WIF

I got two scripts:

First:

Code:

#!/usr/bin/env python3

from mnemonic import Mnemonic
from tqdm import tqdm
import binascii
import bip32utils
import mnemonic
import pprint

mnemo = Mnemonic("english")

def bip39(seed):
	bip32_root_key_obj = bip32utils.BIP32Key.fromEntropy(bytes.fromhex(seed))
	bip32_child_key_obj = bip32_root_key_obj.ChildKey(
		84 + bip32utils.BIP32_HARDEN
	).ChildKey(
		0 + bip32utils.BIP32_HARDEN
	).ChildKey(
		0 + bip32utils.BIP32_HARDEN
	).ChildKey(0).ChildKey(0)

	return bip32_child_key_obj.WalletImportFormat()

with open("input.txt","r") as f:
	lines = f.readlines()

lines = [x.strip() for x in lines]
cnt=len(lines)

o=open("output.txt","w")

for line in tqdm(lines,total=cnt):
	try:
		seed=mnemo.to_seed(line).hex()
		wif=bip39(seed)
		o.write(wif+' 0\n')
		o.flush()
	except:
		continue

Second:

Code:

#!/usr/bin/env python3

from tqdm import tqdm
import base58
import bech32
import binascii
import bip32
import ecdsa
import hashlib
import hdwallets
import mnemonic

# pip3 install ecdsa==0.14

DEFAULT_BECH32_HRP = "cro"
path   = "m/44'/0'/0'/0/0"

def privkey_to_pubkey(privkey: bytes) -> bytes:
    privkey_obj = ecdsa.SigningKey.from_string(privkey, curve=ecdsa.SECP256k1)
    pubkey_obj = privkey_obj.get_verifying_key()
    return pubkey_obj.to_string("compressed")

def pubkey_to_address(pubkey: bytes, *, hrp: str = DEFAULT_BECH32_HRP) -> str:
    s = hashlib.new("sha256", pubkey).digest()
    r = hashlib.new("ripemd160", s).digest()
    five_bit_r = bech32.convertbits(r, 8, 5)
    assert five_bit_r is not None, "Unsuccessful bech32.convertbits call"
    return bech32.bech32_encode(hrp, five_bit_r)

def privkey_to_address(privkey: bytes, *, hrp: str = DEFAULT_BECH32_HRP) -> str:
    pubkey = privkey_to_pubkey(privkey)
    return pubkey_to_address(pubkey, hrp=hrp)

def pvk_to_wif(z):
	private_key_static = z
	extended_key = "80"+private_key_static
	first_sha256 = hashlib.sha256(binascii.unhexlify(extended_key)).hexdigest()
	second_sha256 = hashlib.sha256(binascii.unhexlify(first_sha256)).hexdigest()
	final_key = extended_key+second_sha256[:8]
	return base58.b58encode(binascii.unhexlify(final_key))

cnt=sum(1 for line in open('input.txt'))
i=open('input.txt','r')
o=open('output.txt','w')

for line in tqdm(i,total=cnt):
	mnemo  = line.strip('\n')
	seed_bytes = mnemonic.Mnemonic.to_seed(mnemo)
	hd_wallet = hdwallets.BIP32.from_seed(seed_bytes)
	pvk = hd_wallet.get_privkey_from_path([44,0,0])
	wif = pvk_to_wif(pvk.hex())
	o.write(wif.decode('ascii')+' 0\n')
	o.flush()

o.close()

#!/usr/bin/env python3

import hashlib

def bip39_is_checksum_valid(mnemonic: str) -> bool:
words = mnemonic
words_len = len(words)
with open('english.txt') as f:
wordlist = [line.strip() for line in f]
n = len(wordlist)
i = 0
words.reverse()
while words:
w = words.pop()
try:
k = wordlist.index(w)
except ValueError:
return False, False
i = i*n + k
if words_len not in [12, 15, 18, 21, 24]:
return False
checksum_length = 11 * words_len // 33 # num bits
entropy_length = 32 * checksum_length # num bits
entropy = i >> checksum_length
checksum = i % 2**checksum_length
entropy_bytes = int.to_bytes(entropy, length=entropy_length//8, byteorder="big")
sha=hashlib.sha256()
sha.update(entropy_bytes)
hash=sha.digest()
hashed = int.from_bytes(hash, byteorder="big")
calculated_checksum = hashed >> (256 - checksum_length)
return checksum == calculated_checksum

import sys

m=sys.argv[1:]

if bip39_is_checksum_valid(m)==True:
print('Valid!')
exit(0)
else:
print('Invalid!')
exit(1)