def create_account(role):
""" Create new account """
RECEIVER_PRIVATE_KEY, RECEIVER_ADDRESS = account.generate_account()
amount = 0
algo_amount = 301000
message = ''
if role == 'player':
amount = 1500
message = 'Your account has been created with 1,500 Monopoly Money. Scan QR code.'
elif role == 'banker':
amount = 20000
message = 'Your account has been created with 20,000 Monopoly Money. Scan QR code. '
# Send 0.301 Algo to new account (for opt-in and transaction fees)
algo_transaction(SENDER_ADDRESS, SENDER_PRIVATE_KEY, RECEIVER_ADDRESS, algo_amount)
# Opt-in Monopoly Money Asset
asset_transfer(RECEIVER_ADDRESS, RECEIVER_PRIVATE_KEY, RECEIVER_ADDRESS, 0, ASSET_ID)
# Send Monopoly Money ASA
asset_transfer(SENDER_ADDRESS, SENDER_PRIVATE_KEY, RECEIVER_ADDRESS, amount, ASSET_ID)
# Create PNG file with QR-code which store the passphrase
passphrase = '{{"version":"1.0", "mnemonic":"{}"}}'.format(mnemonic.from_private_key(RECEIVER_PRIVATE_KEY))
qr_code = pyqrcode.create(passphrase)
rnd = random.random()
qr_file = 'static/{}{}.png'.format(RECEIVER_ADDRESS, str(rnd))
qr_code.png(qr_file, scale=6)
return qr_file, message
def create_account(update, context):
"""
Create new public/private key pair
Returns the result of generating an account to user:
:param update:
:param context:
:return: 1). An Algorand address, 2). A mnemonic seed phrase
"""
update.message.reply_text("Hang on while I get you an account ...")
time.sleep(1)
try:
sk, pk = account.generate_account()
mn = mnemonic.from_private_key(sk)
if not (pk and sk is None):
update.message.reply_text("Account creation success.\nAddress: {}\n\n"
"Private Key: {}\n\n"
"Mnemonic:\n {}\n\n"
"I do not hold or manage your keys."
"".format(pk, sk, mn)
)
context.user_data['default_pk'] = pk
update.message.reply_text('To test if your address works fine, copy your address, and visit:\n ')
keyboard = [[InlineKeyboardButton(
"DISPENSER", 'https://bank.testnet.algorand.network/', callback_data='1')]]
dispenser = InlineKeyboardMarkup(keyboard)
update.message.reply_text('the dispenser to get some Algos\nSession ended.'
'Click /start to begin.', reply_markup=dispenser)
except Exception as e:
update.message.reply_text('Account creation error.')
return e
def generate_new_account():
"""
Generate a new Algorand account and print the public address
and private key mnemonic.
"""
private_key, public_address = account.generate_account()
passphrase = mnemonic.from_private_key(private_key)
print("Address: {}\nPassphrase: \"{}\"".format(public_address, passphrase))
def generateBankerAddr(self, ref_number):
if ref_number in self.refNumber:
sk, accountIdentifier = account.generate_account()
seedPhrase = mnemonic.from_private_key(sk)
self.members.append(accountIdentifier) # Remembers bankers identifier
return (seedPhrase, accountIdentifier)
else:
print("You're not recognized")
def setup_cmo():
private_key, account = account_algosdk.generate_account()
# passphrase1 = "faint fog unfair treat enemy disagree host merit bulb lizard client proof aspect cruise vital lion gate victory planet grace weird food phrase absent marriage"
# private_key = mnemonic.to_private_key(passphrase1)
# account = account_algosdk.address_from_private_key(private_key)
print("CMO address: {}".format(account))
print("CMO passphrase: {}".format(mnemonic.from_private_key(private_key)))
return account, private_key
def create_wallet():
"""
Creates an Algorand wallet and returns the mnemonic of the new wallet.
@returns a string of the 25-word passphrase
"""
private_key, account_address = account.generate_account()
passphrase = mnemonic.from_private_key(private_key)
return passphrase
def __repr__(self) -> str:
"""
Returns all information about the wallet in a string
Returns:
str
"""
return WALLET_REPR.substitute(private_key=from_private_key(self.private_key),
public_key=self.public_key,
balance=self.balance,
qr_code_link=self.qrcode)
def generate_algorand_keypair():
print("## START keypair generator ##\n")
private_key, address = account.generate_account()
print("New address: {}".format(address))
print("New passphrase: {}".format(mnemonic.from_private_key(private_key)) +
"\n")
print("# END keypair generator #\n")
return (private_key, address)
def generate_new_account():
"""
Generate a new Algorand account and print the public address
and private key mnemonic.
"""
private_key, public_address = account.generate_account()
passphrase = mnemonic.from_private_key(private_key)
return json.dumps({
"Address": public_address,
"Key": private_key,
"Passphrase": passphrase
})
def export_address(self):
item = self.listWidget.currentItem()
try:
private_key = self.wallet.algo_wallet.export_key(item.text())
except Exception as e:
if __debug__:
print(type(e), str(e), file=stderr)
QtWidgets.QMessageBox.critical(self, "Could not export address",
str(e))
else:
QtGui.QGuiApplication.clipboard().setText(
from_private_key(private_key))
QtWidgets.QMessageBox.information(
self, "Success", "Private key copied into clipboard")
def create_New_Account(
wallet_id, wallet_pass
): #Taken from algorand example.py, changed the variable name to more suitable one
wallet_handle = kcl.init_wallet_handle(wallet_id, wallet_pass)
account_private_key, account_address = account.generate_account()
kcl.import_key(
handle,
accouunt_private_key) # import generated account into the wallet
mnemonice_phrase = mnemonic.from_private_key(account_private_key)
print("Wallet handle token: " + handle + "\n")
print("Private key: " + account_private_key + "\n")
print("Account address: " + account_address)
print("Mnemonic phrase generated for the account:(Keep it safe) " +
mnemonice_phrase + "\n")
algosdk.algod.account_info(address, **kwargs)
def get_mnemonics_from_sk(update, context):
"""
Takes in private key and converts to mnemonics
:param context:
:param update:
:return: 25 mnemonic words
# """
if '/Private_key' in context.user_data:
sk = context.user_data['/Private_key']
phrase = mnemonic.from_private_key(str(sk))
update.message.reply_text(
"Your Mnemonics:\n {}\n\nKeep your mnemonic phrase from prying eyes.\n"
"\nI do not hold or manage your keys.".format(phrase), reply_markup=mappedKeyboard
)
update.message.reply_text('\nSession ended.')
del context.user_data['/Private_key']
else:
update.message.reply_text("Key not found")
# return ConversationHandler.END
return STARTING
def get_test_account(update, context):
"""
Create new public/private key pair
Returns the result of generating an account to user:
:param update:
:param context:
:return: 1). An Algorand address, 2). A mnemonic seed phrase
"""
global mn
update.message.reply_text("Swift!\nYour keys are ready: \n")
try:
sk, pk = account.generate_account()
mn = mnemonic.from_private_key(sk)
address = account.address_from_private_key(sk)
update.message.reply_text("Account address/Public key: {}\n\n"
"Private Key: {}\n\n"
"Mnemonic:\n {}\n\n"
"I do not hold or manage your keys."
"".format(address, sk, mn))
context.user_data['default_pk'] = pk
update.message.reply_text(
'To test if your address works fine, copy your address, and visit:\n '
)
key_board = [[
InlineKeyboardButton("DISPENSER",
'https://bank.testnet.algorand.network/',
callback_data='1')
]]
dispenser = InlineKeyboardMarkup(key_board)
update.message.reply_text(
'the dispenser to get some Algos\nSession ended.'
'Click /start to begin.',
reply_markup=dispenser)
context.user_data.clear()
except Exception as e:
update.message.reply_text('Account creation error.')
return e
def create_account(fund=True):
# Change algod_token and algod_address to connect to a different client
algod_token = "2f3203f21e738a1de6110eba6984f9d03e5a95d7a577b34616854064cf2c0e7b"
algod_address = "https://academy-algod.dev.aws.algodev.network/"
algod_client = algod.AlgodClient(algod_token, algod_address)
#Generate new account for this transaction
secret_key, my_address = account.generate_account()
m = mnemonic.from_private_key(secret_key)
print("My address: {}".format(my_address))
# Check your balance. It should be 0 microAlgos
account_info = algod_client.account_info(my_address)
print("Account balance: {} microAlgos".format(account_info.get('amount')) +
"\n")
if fund:
#Fund the created account
print(
'Go to the below link to fund the created account using testnet faucet: \n https://dispenser.testnet.aws.algodev.network/?account={}'
.format(my_address))
completed = ""
while completed.lower() != 'yes':
completed = input("Type 'yes' once you funded the account: ")
print('Fund transfer in process...')
# Wait for the faucet to transfer funds
time.sleep(5)
print('Fund transferred!')
# Check your balance. It should be 5000000 microAlgos
account_info = algod_client.account_info(my_address)
print("Account balance: {} microAlgos".format(
account_info.get('amount')) + "\n")
return m
def mnemonic(self) -> str:
return mnemonic.from_private_key(self.private_key)
def create_wallet():
""" Create new Algorand wallet """
private_key, address = account.generate_account()
passphrase = mnemonic.from_private_key(private_key)
return private_key, address, passphrase
def check_account(username):
if not models.fetch_user(username):
private_key, address, passphrase = create_wallet()
passphrase = mnemonic.from_private_key(private_key)
models.insert_user(username, address, private_key, passphrase)
return True
def test_mnemonic_private_key(self):
priv_key, address = account.generate_account()
mn = mnemonic.from_private_key(priv_key)
self.assertEqual(len(mn.split(" ")), constants.mnemonic_len)
self.assertEqual(priv_key, mnemonic.to_private_key(mn))
def generate_new_account():
private_key, address = account.generate_account()
print("Created new account: ", address)
print("Generated mnemonic: \"{}\"".format(
mnemonic.from_private_key(private_key)))
return address
def generate_algorand_keypair():
private_key, address = account.generate_account()
print("My address: {}".format(address))
print("My passphrase: {}".format(mnemonic.from_private_key(private_key)))
return private_key, address
txinfo = wait_for_confirmation( acl, txid)
# todo add asset_id return
acl = setup_acl()
# create cmo account
cmo_account, cmo_private_key = setup_cmo()
cmo_list = [cmo_account]
# create rightholder account
private_key, account = account_algosdk.generate_account()
print("Rh address: {}".format(account))
print("Rh passphrase: {}".format(mnemonic.from_private_key(private_key)))
input("Press smt when you have filled the accounts")
# create IPI names & identifier
asset_id_ipi = create_ipi_name(account, private_key)
asset_info_ipi = acl.asset_info(asset_id_ipi)
# print(json.dumps(asset_info_ipi, indent=4))
# create ipi record. Two types: 1) external 2) on-chain
ipi_record_id = create_external_ipi_record(account, private_key, "https://bit.ly/37hQKQa")
ipi_record_id2 = create_succint_ipi_record(asset_info_ipi["unitname"], cclasses_list[1], roles_list[1], rights_list[1], "2000", "2050", 100, ["IT"], account, private_key)
print("Here is how IPI records look like in chain ...")
import params
from algosdk import kmd, mnemonic
from algosdk.wallet import Wallet
# create a kmd client
kcl = kmd.KMDClient(params.kmd_token, params.kmd_address)
# wallet = Wallet("wallet_name", "wallet_password", kcl)
walletid = None
wallets = kcl.list_wallets()
print("Wallet List:", wallets)
for arrayitem in wallets:
if arrayitem.get("name") == "wallet1":
walletid = arrayitem.get("id")
break
print("Wallet ID:", walletid)
wallethandle = kcl.init_wallet_handle(walletid, "testpassword")
print("Wallet Handle:", wallethandle)
accounts = kcl.list_keys(wallethandle)
print("Accounts:", accounts)
accountkey = kcl.export_key(wallethandle, "testpassword", "WHWPLXPIANMRNFB6ZEBJKXMZWRN4NLDK3BNVNOIEEAEUWIJDFVNHNPA3OQ")
print("Account Key:", accountkey)
mn = mnemonic.from_private_key(accountkey)
print("Mnemonic: ", mn)
# wallethandle = wallet.init_handle()
# print("Wallet Handle:", wallethandle)
import base64
from algosdk.v2client import algod
from algosdk import mnemonic
from algosdk import transaction
from Certificate import Certificate
import Algorand
from CertificateIndexer import CertificateIndexer
from CertificateMaker import CertificateMaker
import hashlib
import datetime
import numpy as np
from algosdk import account
# private_key, public_address = account.generate_account()
# print("Base64 Private Key: {}\nPublic Algorand Address: {}\n".format(private_key, public_address))
m = mnemonic.from_private_key(
'x3/x7jdaBWxJZN6IW7DtRw8T/mTMEim1Ca6yXrm1JXTCg+9kOU561gfgnml6qD3wj9cY1W3X4qzlzszEfDjRFw=='
)
print(m)
# x3/x7jdaBWxJZN6IW7DtRw8T/mTMEim1Ca6yXrm1JXTCg+9kOU561gfgnml6qD3wj9cY1W3X4qzlzszEfDjRFw==
# YKB66ZBZJZ5NMB7ATZUXVKB56CH5OGGVNXL6FLHFZ3GMI7BY2EL5EH3UZM
algod_address = "https://testnet-algorand.api.purestake.io/ps2"
algod_token = "zLAOcinLq31BhPezSnHQL3NF7qBwHtku6XwN8igq"
purestake_token = {'X-Api-key': algod_token}
passphrase = "wedding shine wash pet apple force car taxi illegal scrap walnut virtual champion display glimpse barrel pioneer chat finish twenty increase hope patrol about stage"
private_key = mnemonic.to_private_key(passphrase)
my_address = mnemonic.to_public_key(passphrase)
print("My address: {}".format(my_address))
algod_client = algod.AlgodClient(algod_token,
algod_address,
if (len(sys.argv) < 2):
sys.exit(
"usage : convert_mnemonic.py 'my mnemonic phrase' [accountid, default = 0]"
)
words = sys.argv[1]
accountid = "0"
if (len(sys.argv) == 3):
if (sys.argv[2].isdecimal()):
accountid = sys.argv[2]
else:
print("\nWarning: invalid account id, defaulting to 0")
seed = mnemo.to_seed(words, passphrase="")
run_cmd = ["./build/src/privkey_algorand", seed.hex(), accountid]
testRun = subprocess.run(run_cmd,
stdout=subprocess.PIPE,
stdin=None,
cwd=os.path.dirname(os.path.realpath(__file__)),
stderr=subprocess.PIPE,
bufsize=0,
universal_newlines=True,
timeout=100)
privatekey = testRun.stdout.partition('\n')[0]
pkey_hex = binascii.unhexlify(privatekey)
algo_mnemonic = mnemonic.from_private_key(base64.b64encode(pkey_hex))
print("\n" + algo_mnemonic)
import json
from algosdk import account, mnemonic
acct = account.generate_account()
address1 = acct[1]
print("Account 1")
print(address1)
mnemonic1 = mnemonic.from_private_key(acct[0])
print("Account 2")
acct = account.generate_account()
address2 = acct[1]
print(address2)
mnemonic2 = mnemonic.from_private_key(acct[0])
print("Account 3")
acct = account.generate_account()
address3 = acct[1]
print(address3)
mnemonic3 = mnemonic.from_private_key(acct[0])
print("")
print(
"Copy off accounts above and add TestNet Algo funds using the TestNet Dispenser at https://bank.testnet.algorand.network/"
)
print("copy off the following mnemonic code for use later")
print("")
print("mnemonic1 = \"{}\"".format(mnemonic1))
print("mnemonic2 = \"{}\"".format(mnemonic2))
print("mnemonic3 = \"{}\"".format(mnemonic3))
print("Wallet handle token: " + handle + "\n")
# generate account with account and check if it's valid
private_key_1, address_1 = account.generate_account()
print("Private key: " + private_key_1 + "\n")
print("First account: " + address_1)
# import generated account into the wallet
kcl.import_key(handle, private_key_1)
# generate account with kmd
address_2 = kcl.generate_key(handle, False)
print("Second account: " + address_2 + "\n")
# get the mnemonic for address_1
mn = mnemonic.from_private_key(private_key_1)
print("Mnemonic for the first account: " + mn + "\n")
# get suggested parameters
sp = acl.suggested_params()
# get last block info
block_info = acl.block_info(sp.first)
print("Block", sp.first, "info:", json.dumps(block_info, indent=2), "\n")
# create a transaction
amount = 100000
txn = transaction.PaymentTxn(existing_account, sp, address_1, amount)
print("Encoded transaction:", encoding.msgpack_encode(txn), "\n")
# sign transaction with kmd
def createPetition():
form = CreatePetitionForm(request.form)
if form.validate_on_submit():
petitionWallet = "Petitions"
petitionWalletPassword = "******"
masterAccountWallet = "MasterAccounts"
masterAccountWalletPassword = "******"
wallets = kcl.list_wallets()
petitionWalletID = None
for w in wallets:
if w["name"] == petitionWallet:
petitionWalletID = w["id"]
break
masterAccountWalletID = None
for w2 in wallets:
if w2["name"] == masterAccountWallet:
masterAccountWalletID = w2["id"]
break
# if it doesn't exist, create the wallet and get its ID
if not petitionWalletID:
petitionWalletID = kcl.create_wallet(petitionWallet,
petitionWalletPassword)["id"]
# get a handle for the wallet
handle = kcl.init_wallet_handle(petitionWalletID,
petitionWalletPassword)
#### MASTER ACCOUNTS
# if it doesn't exist, create the wallet and get its ID
if not masterAccountWalletID:
masterAccountWalletID = kcl.create_wallet(
masterAccountWallet, masterAccountWalletPassword)["id"]
# get a handle for the wallet
handle2 = kcl.init_wallet_handle(masterAccountWalletID,
masterAccountWalletPassword)
# generate account with account and check if it's valid
private_key_1, address_1 = account.generate_account()
# generate master account with account and check if it's valid
private_key_2, address_2 = account.generate_account()
# import generated account into the wallet
kcl.import_key(handle, private_key_1)
kcl.import_key(handle2, private_key_2)
# get the mnemonic for address_1
mn = mnemonic.from_private_key(private_key_2)
print("Mnemonic for the first account: " + mn + "\n")
petition = Petition(name=form.name.data,
publicKey=address_1,
masterAccount=address_2,
yesCount=0,
startDate=form.startDate.data,
endDate=form.endDate.data)
db.session.add(petition)
db.session.commit()
# Run bash script that automatically transfers microAlgos
# from unencrypted-default-wallet to the desired Peition's
# Master Account.
# subprocess.call(["project/autoDispense.sh",str(address_2)])
flash('Petition has been created!.', 'success')
return render_template('petition/createPetition.html', form=form)
from algosdk import account, mnemonic
private_key, account_address = account.generate_account()
words = mnemonic.from_private_key(private_key)
with open('../accountA.creds', 'w') as fd:
fd.write(f'Account address: {account_address}\n')
fd.write(f'Private key: {private_key}\n')
fd.write(f'Private key mnemonic: {words}')
def sk_to_mn(context):
context.mn = mnemonic.from_private_key(context.sk)
if __name__ == '__main__':
p = argparse.ArgumentParser()
p.add_argument("pattern", type=str, help="Pattern to Look for at the start of an algorand address.")
pattern = p.parse_args().pattern
num_processors = multiprocessing.cpu_count()
print("Detected " + str(num_processors) + " cpu(s)")
start_time = time.time()
count = Value('i', 0)
queue = Queue()
jobs = []
# spawn number of address search processes equal to the number of processors on the system
for i in range(num_processors):
p = Process(target=find_address, args=(pattern, queue, count))
jobs.append(p)
p.start()
signal.signal(signal.SIGINT, signal_handler) # capture ctrl-c so we can report attempts and running time
address, private_key = queue.get() # this will return once one of the spawned processes finds a match
if (address):
print("Found a match for " + pattern + " after " + str(
count.value) + " tries in " + get_running_time() + " seconds")
print("Address: ", address)
print("Private key: ", mnemonic.from_private_key(private_key))
terminate_processes()
