def to_key_pairs(cls, mnemonic):
w = wallet.create_wallet(network="bch", seed=mnemonic, children=1)
wif = w['wif']
key = Key(wif)
address = key.address
keypair = {"private_key_WIF": wif, "address": address}
return keypair
async def wallet_creation(username):
"""
To create a new wallet, the user must be signed in, which means the Client has the
encryptionKey available in the browser’s process memory and a valid JWT.
"""
mnemonic = wallet.generate_mnemonic()
logger.debug(mnemonic)
encryptedMnemonicPhrase = aes_encrypt_CBC(ENCRYPTION_KEY,
mnemonic.encode("utf-8"))
logger.debug(encryptedMnemonicPhrase)
w = wallet.create_wallet(network="ETH", seed=mnemonic, children=1)
pprint(w)
data = {
"username": username,
'eth_address': w["address"],
"encryptedMnemonicPhrase": encryptedMnemonicPhrase.hex()
}
pprint(data)
async with aiohttp.ClientSession(
headers={"Authorization": ID_TOKEN}) as session:
async with session.post(URL_ETHEREUM_UPDATE_MNEMONIC_ADDRESS,
json=data) as response:
result = await response.json()
pprint(result)
return
def create(password=None, coinType=None, network="btctest", number=1):
'''create main wallet'''
# generate 12 word mnemonic seed
seed = wallet.generate_mnemonic()
# create bitcoin wallet
w = wallet.create_wallet(network=network, seed=seed, children=1)
statement = "INSERT INTO account VALUES(?,?,?,?,?,?)"
data = [(1, "main", w['address'], w['private_key'], coinType, seed)]
conn.executemany(statement, data)
conn.commit()
WALLET_PUBKEY = w['xpublic_key']
print(WALLET_PUBKEY)
for index in range(number):
print(index)
child_id = wallet.generate_child_id()
# generate address for specific user (id = 10)
user_addr = wallet.create_address(network=network,
xpub=WALLET_PUBKEY,
child=child_id)
statement = "INSERT INTO account VALUES(?,?,?,?,?,?)"
data = [(index + 2, "child", user_addr['address'], None, coinType,
None)]
conn.executemany(statement, data)
conn.commit()
print("User Address\n", user_addr)
print("============================")
def generate(self):
seed = wallet.generate_mnemonic()
w = wallet.create_wallet(network="omni", seed=seed, children=1)
wif = w.get('wif').decode("utf-8")
address = w.get('address')
seed = w.get('seed')
return CryptoCoin(address, wif, seed)
def main(seed, network, children, pretty, random_seed=False):
'''Where args is the seed to use.
If none specified, reads from STDIN.
pywallet-cli traffic happy world clog clump cattle great toy game absurd alarm auction
cat myseeds.txt | pywallet-cli
pywallet-cli --network=ETH --children=3 --no-pretty --random-seed
'''
# generate 12 word mnemonic seed
if seed:
seed = " ".join(seed)
else:
if random_seed:
seed = wallet.generate_mnemonic()
else:
arr = []
for words in sys.stdin:
arr.extend(words.split())
if len(arr) >= 12:
break
seed = " ".join(arr)
# create bitcoin wallet
w = wallet.create_wallet(network=network, seed=seed, children=children)
b2asc(w)
indent = 4 if pretty else None
print(json.dumps(w, sort_keys=True, indent=indent))
def generate_new_tree(network):
seed = wallet.generate_mnemonic()
w = wallet.create_wallet(network=network, seed=seed, children=1)
return {
'mnemonic': seed,
'xprivate_key': w['xprivate_key'],
'xpublic_key': w['xpublic_key']
}
def create_bchwallet(user):
w = wallet.create_wallet(network="BCH", children=1)
user.wallets.add(
Wallet.objects.create(name='bch',
address=w["address"],
public=w["public_key"],
private=w["private_key"]))
user.save()
return w["address"]
def gen_addr(self):
seed = wallet.generate_mnemonic()
w = wallet.create_wallet(network="BTC", seed=seed, children=1)
address = w["address"]
priv_key = w["private_key"]
newCryptoAddress = CryptoAddress(crypto_type='btc',
crypto_address=address,
crypto_priv_key=priv_key)
newCryptoAddress.save()
return address, priv_key
def create_litewallet(user):
w = wallet.create_wallet(network="LTC", children=0)
params = {
"token": API_KEY_BLOCK,
"name": user.username,
"address": w["address"]
}
response = requests.post('https://api.blockcypher.com/v1/ltc/main/wallets',json=params)
user.wallets.add(Wallet.objects.create(name='ltc', address=w["address"], private=w["private_key"]))
user.save()
return w["address"]
def __init__(self, name, seed, children):
if (seed == "0"):
self.seed = wallet.generate_mnemonic()
else:
self.seed = seed
self.name = name
self.children = children
self.wallet = wallet.create_wallet(network="ETH",
seed=self.seed,
children=self.children)
self.wallet_data = dict(self.wallet)
def __init__(self):
from pywallet import wallet as w
self.coin = ''
self.private_key = ''
self.public_key = ''
self.address = ''
self.seed = w.generate_mnemonic()
self.wallet = w.create_wallet(network='BTC',
seed=self.seed,
children=0)
self.parse_response()
def create_wallet():
seed = wallet.generate_mnemonic()
w = wallet.create_wallet(network="BTC", seed=seed, children=1)
w["coin"] = "UCW"
w["balance"] = 0
try:
w["wif"] = w["wif"].decode("utf-8")
except:
del (w["wif"])
pass
#Add Wallet to DB as well
return w
def createBtcWallet():
seed = wallet.generate_mnemonic()
tempWallet = wallet.create_wallet(network="BTC", seed=seed, children=1)
now = datetime.datetime.now()
#this creates the logfile which stores the seed and public key incase of exchange faliure
file = open("BTClog.txt", "a")
file.write(now.strftime("%Y-%m-%d %H:%M:%S Generated Seed: "))
file.write(seed)
file.write("\n")
file.write("Refund Public Key: ")
#this line writes the actual public address
file.write(tempWallet['address'])
file.write("\n")
file.close()
return (tempWallet['address'])
def generate_ethereum_wallet(query_params={}):
if blockchain_validator.generate_litecoin_wallet(query_params):
if query_params != {}:
mnemonic = query_params['mnemonic']
else:
mnemonic = wallet.generate_mnemonic(strength=256)
if Bip39MnemonicValidator(mnemonic).Validate():
w = wallet.create_wallet(network="ETH", seed=mnemonic, children=1)
return {
"xpriv": w['xprivate_key'].decode("utf-8"),
"xpub": w['xpublic_key'].decode("utf-8"),
"mnemonic": mnemonic
}
else:
return 'Mnemonic is not valid!'
def create_adminwallet(request):
ctx = {}
if request.method == 'POST':
seed = wallet.generate_mnemonic()
w = wallet.create_wallet(network='ETH', seed=seed)
coin = 'ETH'
xpub = w['xpublic_key']
xpriv = w['xprivate_key']
address = w['address']
admin_wallet = Admin_wallet.objects.create(seed=seed,
coin=coin,
xpub=xpub,
xpriv=xpriv,
address=address)
ctx = {'admin_wallet': admin_wallet}
return render(request, 'create_adminwallet.html', ctx)
def get_name_from_emoji():
if request.args is None:
return make_response(jsonify({'message': 'No name provided'})), 401
emoji_unicodes = list(request.args.to_dict().values())
seed = ''.join([emoji for emoji in emoji_unicodes])
w = wallet.create_wallet(network="ETH", seed=seed)
nw = models.Wallet.query.filter_by(address=w.get('address')).first()
if nw is None:
return make_response(jsonify({'nameResult':
'No name found for seed'})), 404
response_object = {'nameResult': nw.name}
return make_response(jsonify(response_object)), 200
def generate_wallet_from_name():
name = request.json.get('name')
if name is None:
return make_response(jsonify({'privateKey': 'No name provided'})), 401
seed = generate_seed_emoji()
# generate hierarchical deterministic wallet
w = wallet.create_wallet(network="ETH", seed=seed)
nw = models.Wallet(private_key=w.get('private_key'),
address=w.get('address'),
name=name)
db.session.add(nw)
db.session.commit()
response_object = {'privateKey': w.get('seed')}
return make_response(jsonify(response_object)), 201
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from pywallet import wallet
seed = 'horror please embark security repair unfair stock stone engage taxi diesel silent'
for net in ["BTC", "DOGE", "LTC", "BCH", "BTG", "DASH", "ETH"]:
my_wallet = wallet.create_wallet(net, seed)
print("----------------------------")
print(net)
print(my_wallet['xpublic_key'])
print(
wallet.create_address(net,
my_wallet['xpublic_key'],
child=0,
is_prime=True))
print("----------------------------")
def create_hd_wallet(self, seed=None):
return create_wallet(self.network, seed)
import logging import string import socket from pywallet import wallet # generate 12 word mnemonic seed seed = wallet.generate_mnemonic() # create bitcoin wallet w = wallet.create_wallet(network="btctest", seed=seed, children=1) print(w)
def create_ltc_wallet(user):
w = wallet.create_wallet(network="LTC", children=0)
wallet = Wallet.objects.create(user=user, name='ltc')
wallet.addresses.add(WalletAddress.objects.create(address=w["address"]))
return w["address"]
def create_addr(self):
wallet = create_wallet(self.NET_WALLET)
return to_string(wallet['address']), to_string(wallet['wif'])
def create_hd_wallet(self, seed=None):
wallet = create_wallet(self.network, seed)
self.proxy.make_request('importaddress', wallet['address'])
return wallet
from pywallet import wallet seed = wallet.generate_mnemonic() w = wallet.create_wallet(network="BTC", seed=seed, children=1) print(w)
from pywallet import wallet
print("Welcome to BM Hd wallet generator1.1!!")
print("this is a program that simply generates 7 different cryptocurrency address")
print("------------------------------------")
print("Bitcoin:BTC \n BitcoinCash:BCH \n BitcoinGold:BTG \n Ethereum:ETH \n LiteCoin:LTC \n Dash:DSH \n DogeCoin:DOGE")
print(" ")
print("for supporting us , you can donate BTC to address below:")
print("36XJBnHvuk57tMeCYNUGSXFrR72tzhHBuk")
print(" ")
coin = input("Enter the symbol of cryptocurrency to generate a wallet. like BTC(they must be in uppercase): ")
seed = wallet.generate_mnemonic()
w = wallet.create_wallet(network=coin, seed=seed, children=1)
print(w)
save = input("save this wallet information into a txt file?[y/n]")
if save == "y" :
input("make sure you move the last wallet files to another directory. Press enter ")
files = open ("walletinfo.txt","w")
ww = str(w)
files.write(ww)
files.close()
input("information has been saved in [walletinfo.txt] press enter to exit")
exit()
else :
exit()
def create_bch_wallet(user):
w = wallet.create_wallet(network="BCH", children=1)
wallet = Wallet.objects.create(user=user, name='btg')
wallet.addresses.add(WalletAddress.objects.create(address=w["address"]))
return w["address"]
def gen_wallet():
seed = wallet.generate_mnemonic()
w = wallet.create_wallet(network="BTC", seed=seed, children=1)
return jsonify(w), 200
from pywallet import wallet
import time
from datetime import datetime
now = datetime.now()
current_time = now.strftime("%H:%M:%S")
print("I started at ", current_time)
success = 0
i = 0
while i < 100000:
seed = wallet.generate_mnemonic()
w = wallet.create_wallet(network="Doge", seed=seed, children=0)
if str(w["address"])[0:4].upper() == "DOGE":
print(w["address"])
print(str(w["address"])[0:4].upper())
print(str(w["wif"])[2:len(str(w["wif"])) - 1])
success = 1
i = 1000000
i = i + 1
print("current loop: " + str(i), '\r', end="")
print("")
now = datetime.now()
current_time = now.strftime("%H:%M:%S")
print("I ended at ", current_time)
print("It took me " + str(i) + " loops")
if success == 1:
print("to find a vanity address")
if success == 0:
print("and I still haven't found what I'm looking for...")
