def generateAccounts(): # generate accounts 1 and 2 private_key_1, address_1 = account.generate_account() private_key_2, address_2 = account.generate_account() private_key_3, address_3 = account.generate_account() account_1 = { "pkey": private_key_1, "alc_address": address_1, "alc_information": forAlcInfo.account_info(address_1) } account_2 = { "pkey": private_key_2, "alc_address": address_2, "alc_information": forAlcInfo.account_info(address_2) } account_3 = { "pkey": private_key_3, "alc_address": address_3, "alc_information": forAlcInfo.account_info(address_3) } # store accounts 1 and 2 accounts["account_1"] = account_1 accounts["account_2"] = account_2 accounts["account_3"] = account_3 return (accounts)
def test_errors(self): # get random private key private_key_1, account_1 = account.generate_account() private_key_2, account_2 = account.generate_account() private_key_3, account_3 = account.generate_account() # create transaction gh = "JgsgCaCTqIaLeVhyL6XlRu3n7Rfk2FxMeK+wRSaQ7dI=" txn = transaction.PaymentTxn(account_2, 3, 1234, 1334, gh, account_2, 1000) # create multisig address with invalid version msig = transaction.Multisig(2, 2, [account_1, account_2]) self.assertRaises(error.UnknownMsigVersionError, msig.validate) # change it to have invalid threshold msig.version = 1 msig.threshold = 3 self.assertRaises(error.InvalidThresholdError, msig.validate) # try to sign multisig transaction msig.threshold = 2 mtx = transaction.MultisigTransaction(txn, msig) self.assertRaises(error.BadTxnSenderError, mtx.sign, private_key_1) # change sender address to be correct txn.sender = msig.address() mtx = transaction.MultisigTransaction(txn, msig) # try to sign with incorrect private key self.assertRaises(error.InvalidSecretKeyError, mtx.sign, private_key_3) # create another multisig with different address msig_2 = transaction.Multisig(1, 2, [account_2, account_3]) # try to merge with different addresses mtx_2 = transaction.MultisigTransaction(txn, msig_2) self.assertRaises(error.MergeKeysMismatchError, transaction.MultisigTransaction.merge, [mtx, mtx_2]) # create another multisig with same address msig_3 = msig_2.get_multisig_account() # add mismatched signatures msig_2.subsigs[0].signature = "sig2" msig_3.subsigs[0].signature = "sig3" # try to merge self.assertRaises(error.DuplicateSigMismatchError, transaction.MultisigTransaction.merge, [ transaction.MultisigTransaction(txn, msig_2), transaction.MultisigTransaction(txn, msig_3) ])
def create_trashbag(): kcl = kmd.KMDClient(params.kmd_token, params.kmd_address) acl = algod.AlgodClient(params.algod_token, params.algod_address) petitionWallet = "Petitions" petitionWalletPassword = "******" # get the wallet ID wallets = kcl.list_wallets() petitionWalletID = None for w in wallets: if w["name"] == petitionWallet: petitionWalletID = w["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) # generate account with account and check if it's valid private_key_1, address_1 = account.generate_account() # import generated account into the wallet kcl.import_key(handle, private_key_1) """Creates trash bag account for all petitions.""" petition = Petition(name="Trash Bag Account", publicKey=address_1, masterAccount=address_1, yesCount=0) db.session.add(petition) db.session.commit()
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 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 test_verify_negative(self): sk, pk = account.generate_account() intarray = [random.randint(0, 255) for x in range(15)] message = bytes(intarray) signature = util.sign_bytes(message, sk) intarray[0] = (intarray[0] + 1) % 256 changed_message = bytes(intarray) self.assertFalse(util.verify_bytes(changed_message, signature, pk))
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 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 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 generate(cls) -> "Wallet": """ Generates a public/private key pair Returns: wallet: an instance of the class Wallet with the generated keys """ private_key, public_key = generate_account() return cls(private_key, public_key)
def create_event(name): al = algod.AlgodClient(al_token, al_address) key, address = account.generate_account() eid = len(read_events()) + 1 return { "name": name, "id": eid, "private_key": key, "address": address }
def find_address(pattern, queue, count): while True: with count.get_lock(): count.value += 1 # generate an account using algosdk private_key, address = account.generate_account() if address.startswith(pattern): queue.put((address, private_key)) break
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 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_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 create_bid(context): context.sk, pk = account.generate_account() context.bid = auction.Bid(pk, 1, 2, 3, pk, 4)
def gen_key(context): context.sk, context.pk = account.generate_account() context.old = context.pk
# Example: accepting assets from algosdk import account from algosdk.future import transaction private_key, address = account.generate_account() fee_per_byte = 10 first_valid_round = 1000 last_valid_round = 2000 genesis_hash = "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=" receiver = address # to start accepting assets, set receiver to sender amount = 0 # to start accepting assets, set amount to 0 index = 1234 # identifying index of the asset # create the asset accept transaction sp = transaction.SuggestedParams(fee_per_byte, first_valid_round, last_valid_round, genesis_hash) txn = transaction.AssetTransferTxn(address, sp, receiver, amount, index) # sign the transaction signed_txn = txn.sign(private_key)
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)
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))
acl = algod.AlgodClient(params.algod_token, params.algod_address) 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) # getting wallethandle wallethandle = kcl.init_wallet_handle(walletid, "testpassword") print("Wallet Handle:", wallethandle) # generate and print account 1 private_key1, address_1 = account.generate_account() print("Private key:", private_key1) print("Address:", address_1) # generate and print account 2 private_key2, address_2 = account.generate_account() print("Private key:", private_key2) print("Address:", address_2) # create a msig object version = 1 # multisig version threshold = 1 # how many signatures are necessary msig = transaction.Multisig(version, threshold, [address_1, address_2]) # import msig object(multisig account) into kmd wallet imported_multisig = kcl.import_multisig(wallethandle, msig)
# Example: creating a LogicSig transaction signed by a program that never approves the transfer. import tokens from algosdk import algod, account from algosdk.future import transaction program = b"\x01\x20\x01\x00\x22" # int 0 lsig = transaction.LogicSig(program) sender = lsig.address() receiver = account.generate_account() # create an algod client acl = algod.AlgodClient(tokens.algod_token, tokens.algod_address) # get suggested parameters sp = acl.suggested_params() # create a transaction amount = 10000 txn = transaction.PaymentTxn(sender, sp, receiver, amount) # note: transaction is signed by logic only (no delegation) # that means sender address must match to program hash lstx = transaction.LogicSigTransaction(txn, lsig) assert lstx.verify() # send them over network acl.send_transaction(lstx)
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
# Example: sending assets from algosdk import account from algosdk.future import transaction sender_private_key, sender_address = account.generate_account() fee_per_byte = 10 first_valid_round = 1000 last_valid_round = 2000 genesis_hash = "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=" _, close_assets_to = account.generate_account() _, receiver = account.generate_account() amount = 100 # amount of assets to transfer index = 1234 # identifying index of the asset # create the asset transfer transaction sp = transaction.SuggestedParams(fee_per_byte, first_valid_round, last_valid_round, genesis_hash) txn = transaction.AssetTransferTxn(sender_address, sp, receiver, amount, index, close_assets_to) # sign the transaction signed_txn = txn.sign(sender_private_key)
# possibly replace MultisigTransaction method with Multisig # https://github.com/algorand/py-algorand-sdk/blob/b079db660ae92d0dbf24dc04f28eb722711e426f/algosdk/transaction.py#L893 import params from algosdk import account, transaction, algod, encoding acl = algod.AlgodClient(params.algod_token, params.algod_address) # generate three accounts private_key_1, account_1 = account.generate_account() private_key_2, account_2 = account.generate_account() private_key_3, account_3 = account.generate_account() print("Account 1:", account_1) print("Account 2", account_2) print("Account 3:", account_3) # create a multisig account version = 1 # multisig version threshold = 2 # how many signatures are necessary msig = transaction.Multisig(version, threshold, [account_1, account_2]) print("Multig Account: ", msig.address()) input( "Please go to: https://bank.testnet.algorand.network/ to fund your multisig account." + '\n' + "Press Enter to continue...") # get suggested parameters params = acl.suggested_params() gen = params["genesisID"] gh = params["genesishashb64"] last_round = params["lastRound"] fee = params["fee"]
def getting_started_example(): # Using Rand Labs Developer API # see https://github.com/algorand/py-algorand-sdk/issues/169 # 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_address = "http://hackathon.algodev.network:9100" # algod_token = "ef920e2e7e002953f4b29a8af720efe8e4ecc75ff102b165e0472834b25832c1" algod_address = "http://hackathon.algodev.network:9100" algod_token = "ef920e2e7e002953f4b29a8af720efe8e4ecc75ff102b165e0472834b25832c1" # algod_address = "http://localhost:4001" # algod_token = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" algod_client = algod.AlgodClient(algod_token, algod_address) # Generate new account for this transaction secret_key, my_address = account.generate_account() print("My address: {}".format(my_address)) print("My private key: {}".format(secret_key)) # 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") # Fund the created account print( '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(10) 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") # build transaction print("Building transaction") params = algod_client.suggested_params() # comment out the next two (2) lines to use suggested fees # params.flat_fee = True # params.fee = 1000 receiver = "HZ57J3K46JIJXILONBBZOHX6BKPXEM2VVXNRFSUED6DKFD5ZD24PMJ3MVA" note = "Hello World".encode() amount = 100000 closeto = "HZ57J3K46JIJXILONBBZOHX6BKPXEM2VVXNRFSUED6DKFD5ZD24PMJ3MVA" # Fifth argument is a close_remainder_to parameter that creates a payment txn that sends all of the remaining funds to the specified address. If you want to learn more, go to: https://developer.algorand.org/docs/reference/transactions/#payment-transaction unsigned_txn = transaction.PaymentTxn(my_address, params, receiver, amount, closeto, note) # sign transaction print("Signing transaction") signed_txn = unsigned_txn.sign(secret_key) print("Sending transaction") txid = algod_client.send_transaction(signed_txn) print('Transaction Info:') print("Signed transaction with txID: {}".format(txid)) # wait for confirmation try: print("Waiting for confirmation") confirmed_txn = transaction.wait_for_confirmation( algod_client, txid, 4) except Exception as err: print(err) return print( "txID: {}".format(txid), " confirmed in round: {}".format( confirmed_txn.get("confirmed-round", 0))) print("Transaction information: {}".format( json.dumps(confirmed_txn, indent=4))) print("Decoded note: {}".format( base64.b64decode(confirmed_txn["txn"]["txn"]["note"]).decode())) print("Starting Account balance: {} microAlgos".format( account_info.get('amount'))) print("Amount transfered: {} microAlgos".format(amount)) print("Fee: {} microAlgos".format(params.min_fee)) closetoamt = account_info.get('amount') - (params.min_fee + amount) print("Close to Amount: {} microAlgos".format(closetoamt) + "\n") account_info = algod_client.account_info(my_address) print("Final Account balance: {} microAlgos".format( account_info.get('amount')) + "\n")
# Example: updating asset configuration from algosdk import account from algosdk.future import transaction manager_private_key, manager_address = account.generate_account( ) # this transaction must be sent from the manager's account _, new_freeze = account.generate_account( ) # account that can freeze other accounts for this asset _, new_manager = account.generate_account( ) # account able to update asset configuration _, new_clawback = account.generate_account( ) # account allowed to take this asset from any other account _, new_reserve = account.generate_account( ) # account that holds reserves for this asset fee_per_byte = 10 first_valid_round = 1000 last_valid_round = 2000 genesis_hash = "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=" index = 1234 # identifying index of the asset # create the asset config transaction sp = transaction.SuggestedParams(fee_per_byte, first_valid_round, last_valid_round, genesis_hash) txn = transaction.AssetConfigTxn(manager_address, sp, manager=new_manager, reserve=new_reserve, freeze=new_freeze,
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