def write_multisig_signed_transaction_to_file(): algod_client = connect_to_network() # Change these values with mnemonics # mnemonic1 = "PASTE phrase for account 1" # mnemonic2 = "PASTE phrase for account 2" # mnemonic3 = "PASTE phrase for account 3" mnemonic1 = "patrol target joy dial ethics flip usual fatigue bulb security prosper brand coast arch casino burger inch cricket scissors shoe evolve eternal calm absorb school" mnemonic2 = "genius inside turtle lock alone blame parent civil depend dinosaur tag fiction fun skill chief use damp daughter expose pioneer today weasel box about silly" mnemonic3 = "off canyon mystery cable pluck emotion manual legal journey grit lunch include friend social monkey approve lava steel school mango auto cactus huge ability basket" # For ease of reference, add account public and private keys to # an accounts dict. private_key_1 = mnemonic.to_private_key(mnemonic1) account_1 = mnemonic.to_public_key(mnemonic1) private_key_2 = mnemonic.to_private_key(mnemonic2) account_2 = mnemonic.to_public_key(mnemonic2) private_key_3 = mnemonic.to_private_key(mnemonic3) account_3 = mnemonic.to_public_key(mnemonic3) # create a multisig account version = 1 # multisig version threshold = 2 # how many signatures are necessary msig = Multisig(version, threshold, [account_1, account_2]) print("Multisig Address: ", msig.address()) print( "Please go to: https://bank.testnet.algorand.network/ to fund multisig account.", msig.address()) # input("Please go to: https://bank.testnet.algorand.network/ to fund multisig account." + '\n' + "Press Enter to continue...") # get suggested parameters params = algod_client.suggested_params() # comment out the next two (2) lines to use suggested fees # params.flat_fee = True # params.fee = 1000 # create a transaction sender = msig.address() recipient = account_3 amount = 10000 note = "Hello Multisig".encode() txn = PaymentTxn(sender, params, recipient, amount, None, note, None) # create a SignedTransaction object mtx = MultisigTransaction(txn, msig) # sign the transaction mtx.sign(private_key_1) mtx.sign(private_key_2) # print encoded transaction print(encoding.msgpack_encode(mtx)) # write to file dir_path = os.path.dirname(os.path.realpath(__file__)) transaction.write_to_file([mtx], dir_path + "/signed.mtx") print("Signed mtx file saved!")
def read_multisig_unsigned_transaction_from_file(): algod_client = connect_to_network() # Change these values with mnemonics # mnemonic1 = "PASTE phrase for account 1" # mnemonic2 = "PASTE phrase for account 2" # mnemonic3 = "PASTE phrase for account 3" mnemonic1 = "patrol target joy dial ethics flip usual fatigue bulb security prosper brand coast arch casino burger inch cricket scissors shoe evolve eternal calm absorb school" mnemonic2 = "genius inside turtle lock alone blame parent civil depend dinosaur tag fiction fun skill chief use damp daughter expose pioneer today weasel box about silly" mnemonic3 = "off canyon mystery cable pluck emotion manual legal journey grit lunch include friend social monkey approve lava steel school mango auto cactus huge ability basket" # For ease of reference, add account public and private keys to # an accounts dict. private_key_1 = mnemonic.to_private_key(mnemonic1) account_1 = mnemonic.to_public_key(mnemonic1) private_key_2 = mnemonic.to_private_key(mnemonic2) account_2 = mnemonic.to_public_key(mnemonic2) private_key_3 = mnemonic.to_private_key(mnemonic3) account_3 = mnemonic.to_public_key(mnemonic3) print("Account 1 address: {}".format(account_1)) print("Account 2 address: {}".format(account_2)) print("Account 3 address: {}".format(account_3)) # read from file dir_path = os.path.dirname(os.path.realpath(__file__)) msigs = transaction.retrieve_from_file(dir_path + "/unsigned.mtx") mtx = msigs[0] # sign the transaction mtx.sign(private_key_1) mtx.sign(private_key_2) # send the transaction txid = algod_client.send_raw_transaction(encoding.msgpack_encode(mtx)) # wait for confirmation try: confirmed_txn = wait_for_confirmation(algod_client, txid, 4) print("TXID: ", txid) print("Result confirmed in round: {}".format( confirmed_txn['confirmed-round'])) print("Transaction information: {}".format( json.dumps(confirmed_txn, indent=4))) print("Decoded note: {}".format( base64.b64decode(confirmed_txn["txn"]["txn"]["note"]).decode())) except Exception as err: print(err)
def get_accounts(network): if (network == "Testnet"): # SQEZQ2G5KAI4GM3LM6VRDTTLWQO6JDOSZHNG4Q5BJ4FZ34GVNTBZWFBURU passphrase = "hotel wide vital oak frost example stove coast hero toward win tail climb hero reveal army hole old habit parade cereal such nephew absent inhale" private_key = mnemonic.to_private_key(passphrase) my_address = mnemonic.to_public_key(passphrase) print("My address: {}".format(my_address)) return [(my_address, private_key)] else: kmd = KMDClient(KMD_TOKEN, KMD_ADDRESS) wallets = kmd.list_wallets() walletID = None for wallet in wallets: if wallet["name"] == KMD_WALLET_NAME: walletID = wallet["id"] break if walletID is None: raise Exception("Wallet not found: {}".format(KMD_WALLET_NAME)) walletHandle = kmd.init_wallet_handle(walletID, KMD_WALLET_PASSWORD) try: addresses = kmd.list_keys(walletHandle) privateKeys = [ kmd.export_key(walletHandle, KMD_WALLET_PASSWORD, addr) for addr in addresses ] kmdAccounts = [(addresses[i], privateKeys[i]) for i in range(len(privateKeys))] finally: kmd.release_wallet_handle(walletHandle) return kmdAccounts
def claim_interest(programstr, escrow_id, passphrase, amt, coupon, payment_id, interest_id, par_id, first_block, last_block, algod_client: algod_client()): add = mnemonic.to_public_key(passphrase) key = mnemonic.to_private_key(passphrase) sp = algod_client.suggested_params() sp.first = first_block sp.last = last_block sp.flat_fee = True sp.fee = 1000 print("--------------------------------------------") print("Bundling interest claim and submitting......") txn1 = AssetTransferTxn(add, sp, escrow_id, amt, interest_id) txn2 = AssetTransferTxn(add, sp, add, amt, par_id) txn3 = AssetTransferTxn(escrow_id, sp, add, amt * coupon, payment_id) t = programstr.encode() program = base64.decodebytes(t) arg = (4).to_bytes(8, 'big') lsig = LogicSig(program, args=[arg]) grp_id = calculate_group_id([txn1, txn2, txn3]) txn1.group = grp_id txn2.group = grp_id txn3.group = grp_id stxn1 = txn1.sign(key) stxn2 = txn2.sign(key) stxn3 = LogicSigTransaction(txn3, lsig) signed_group = [stxn1, stxn2, stxn3] tx_id = algod_client.send_transactions(signed_group) wait_for_confirmation(algod_client, tx_id, 200) print("Successfully committed transaction!") print("--------------------------------------------")
def send_tokens(receiver_pk, tx_amount): params = acl.suggested_params() gen_hash = params.gh first_valid_round = params.first tx_fee = params.min_fee last_valid_round = params.last #Your code here #generate an account mnemonic_secret = 'ship floor pattern transfer fiscal diamond maid raise never debate lemon brown siren upset gun sibling lend write cloth success glove shrug cattle ability ivory' sk = mnemonic.to_private_key(mnemonic_secret) pk = mnemonic.to_public_key(mnemonic_secret) print("my public key = ", pk) account_info = acl.account_info(pk) #prepare and sign the transaction tx = transaction.PaymentTxn(pk, tx_fee, first_valid_round, last_valid_round, gen_hash, receiver_pk, tx_amount) signed_tx = tx.sign(sk) #send the signed transaction tx_confirm = acl.send_transaction(signed_tx) #acl.status_after_block(first_valid_round+2) txid = signed_tx.transaction.get_txid() wait_for_confirmation(acl, txid) sender_pk = pk return sender_pk, txid
def distribute_dividends(asset_info): print("Distributing dividends for: ", asset_info['bond_name']) params = algod_client.suggested_params() purchases = [purchase for purchase in db.transaction.find({}) if purchase['asset_id'] == asset_info['asset_id'] and purchase['action'] == 'BUY'] for purchase in purchases: user_id = purchase['user_id'] user = db.user.find_one({'_id': user_id}) user_mnemonic = user['mnemonic'] user_pk = mnemonic.to_public_key(user_mnemonic) amount = int(asset_info["coupon_rate"])/100*int(asset_info["face_value"]) *\ (int(purchase['tokens'])/asset_info['issue_size']) # Fraction of real estate owned ## txn = AssetTransferTxn( sender=accounts[1]['pk'], sp=params, receiver=user_pk, amt=int(amount), index=USDT_asset_id) stxn = txn.sign(accounts[1]['sk']) txid = algod_client.send_transaction(stxn) print(txid) # Wait for the transaction to be confirmed wait_for_confirmation(algod_client, txid) # The balance should now be 10. print_asset_holding(algod_client, user_pk, USDT_asset_id) # Save Dividend Transaction db_dividend_tx = db.dividends.insert_one({ 'user_id': user_mnemonic, 'amount': amount, 'asset_id': asset_info['asset_id'] })
def write_signed_transaction_to_file(): algod_client = connect_to_network() passphrase = "price clap dilemma swim genius fame lucky crack torch hunt maid palace ladder unlock symptom rubber scale load acoustic drop oval cabbage review abstract embark" # generate a public/private key pair my_address = mnemonic.to_public_key(passphrase) print("My address: {}".format(my_address)) account_info = algod_client.account_info(my_address) print("Account balance: {} microAlgos".format(account_info.get('amount'))) # build 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 = "GD64YIY3TWGDMCNPP553DZPPR6LDUSFQOIJVFDPPXWEG3FVOJCCDBBHU5A" note = "Hello World".encode() unsigned_txn = PaymentTxn( my_address, params, receiver, 100000, None, note) # sign transaction signed_txn = unsigned_txn.sign(mnemonic.to_private_key(passphrase)) # write to file dir_path = os.path.dirname(os.path.realpath(__file__)) transaction.write_to_file([signed_txn], dir_path + "/signed.txn")
def read_unsigned_transaction_from_file(): algod_client = connect_to_network() passphrase = "price clap dilemma swim genius fame lucky crack torch hunt maid palace ladder unlock symptom rubber scale load acoustic drop oval cabbage review abstract embark" my_address = mnemonic.to_public_key(passphrase) print("My address: {}".format(my_address)) account_info = algod_client.account_info(my_address) print("Account balance: {} microAlgos".format(account_info.get('amount'))) dir_path = os.path.dirname(os.path.realpath(__file__)) txns = transaction.retrieve_from_file(dir_path + "/unsigned.txn") # sign and submit transaction txn = txns[0] signed_txn = txn.sign(mnemonic.to_private_key(passphrase)) txid = signed_txn.transaction.get_txid() print("Signed transaction with txID: {}".format(txid)) try: txid = algod_client.send_transaction(signed_txn) # wait for confirmation confirmed_txn = wait_for_confirmation(algod_client, txid, 4) print("TXID: ", txid) print("Result confirmed in round: {}".format(confirmed_txn['confirmed-round'])) except Exception as err: print(err) return print("Transaction information: {}".format( json.dumps(confirmed_txn, indent=4))) print("Decoded note: {}".format(base64.b64decode( confirmed_txn["txn"]["txn"]["note"]).decode()))
def send_note(): algod_address = "https://testnet-algorand.api.purestake.io/ps2" algod_token = "WgL4G2ZZf22GsqUIKHvCY9BSJyXQzZS8aTIpnMnp" headers = { "X-API-Key": algod_token, } algod_client = algod.AlgodClient(algod_token, algod_address, headers) # In addition to setting up the client and transaction # See GitHub for wait_for_confirmation() definition # get suggested parameters from Algod params = algod_client.suggested_params() gen = params.gen gh = params.gh first_valid_round = params.first last_valid_round = params.last fee = params.min_fee send_amount = 1 passphrase = "giraffe push drop glove cave cancel around roof talk example surprise atom foil outside anger right pistol stadium agent scheme patient script enrich able green" private_key = mnemonic.to_private_key(passphrase) my_address = mnemonic.to_public_key(passphrase) print("My address: {}".format(my_address)) params = algod_client.suggested_params() print(params) # comment out the next two (2) lines to use suggested fees params.flat_fee = True params.fee = 1000 note = 'd8fc8839456e636d5cd3cb7e8642ce5a4d2b3a53bc02690d2b2ea0b0639c57eb'.encode( ) #content should be the hash receiver = "GOXL7P62EJNZF6B2ISN3EHT3NX6NWD4HQ77ER7WJRQRO5YGHNGT3RGL5LA" unsigned_txn = PaymentTxn(my_address, params, receiver, 1000000, None, note) # sign transaction signed_txn = unsigned_txn.sign(private_key) # send transaction txid = algod_client.send_transaction(signed_txn) print("Send transaction with txID: {}".format(txid)) # wait for confirmation try: confirmed_txn = 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=2))) print("Decoded note: {}".format( base64.b64decode(confirmed_txn["txn"]["txn"]["note"]).decode()))
def replenish_account(passphrase, escrow_id, amt, payment_id, algod_client): add = mnemonic.to_public_key(passphrase) key = mnemonic.to_private_key(passphrase) sp = algod_client.suggested_params() sp.flat_fee = True sp.fee = 1000 txn = AssetTransferTxn(add, sp, escrow_id, amt, payment_id) stxn = txn.sign(key) tx_id = algod_client.send_transaction(stxn) wait_for_confirmation(algod_client, tx_id, 10)
def algorandSequence(): algod_address = "https://testnet-algorand.api.purestake.io/ps2" algod_token = "" headers = { "X-API-Key": "zLAOcinLq31BhPezSnHQL3NF7qBwHtku6XwN8igq", } algod_client = algod.AlgodClient(algod_token, algod_address, headers) status = algod_client.status() print(json.dumps(status, indent=4)) passphrase = "thunder fun scout myself talk repeat hurry miracle puppy run vocal vicious shove fever idea lens above diesel action pulp before cigar horror above mass" private_key = mnemonic.to_private_key(passphrase) my_address = mnemonic.to_public_key(passphrase) print("My address: {}".format(my_address)) account_info = algod_client.account_info(my_address) print("Account balance: {} microAlgos".format(account_info.get('amount'))) params = algod_client.suggested_params() note = "Hello World".encode() receiver = "GD64YIY3TWGDMCNPP553DZPPR6LDUSFQOIJVFDPPXWEG3FVOJCCDBBHU5A" data = { "sender": my_address, "receiver": receiver, "fee": params.get('minFee'), "flat_fee": True, "amt": 20, "first": params.get('lastRound'), "last": params.get('lastRound') + 1000, "note": note, "gen": params.get('genesisID'), "gh": params.get('genesishashb64') } txn = transaction.PaymentTxn(**data) signed_txn = txn.sign(private_key) txid = signed_txn.transaction.get_txid() print("Signed transaction with txID: {}".format(txid)) algod_client.send_transaction( signed_txn, headers={'content-type': 'application/x-binary'}) wait_for_confirmation(algod_client, txid) try: confirmed_txn = algod_client.transaction_info(my_address, txid) except Exception as err: print(err) print("Transaction information: {}".format( json.dumps(confirmed_txn, indent=4))) print("Decoded note: {}".format( base64.b64decode(confirmed_txn.get('noteb64')).decode()))
def p2p_order(buyer, seller, order_details): params = algod_client.suggested_params() buyer_pk = mnemonic.to_public_key(buyer) buyer_sk = mnemonic.to_private_key(buyer) seller_pk = mnemonic.to_public_key(seller) seller_sk = mnemonic.to_private_key(seller) # activate buyer's account print("Activating Buyer's account") activate_account(order_details['asset_id'], buyer) # Token transaction print("\n Executing Token Transaction") token_txn = AssetTransferTxn( sender=seller_pk, sp=params, receiver=buyer_pk, amt=int(order_details['token_amount']), index=order_details['asset_id']) token_stxn = token_txn.sign(seller_sk) token_txid = algod_client.send_transaction(token_stxn) print(token_txid) wait_for_confirmation(algod_client, token_txid) print_asset_holding(algod_client, buyer_pk, order_details['asset_id']) # Activating USDT for seller print("Activating USDT for Seller") activate_account(USDT_asset_id, seller) # USDT Transaction print("\n USDT Transaction") usdt_txn = AssetTransferTxn( sender=buyer_pk, sp=params, receiver=seller_pk, amt=int(order_details['usdt_amount']), index=USDT_asset_id) usdt_stxn = usdt_txn.sign(buyer_sk) usdt_txid = algod_client.send_transaction(usdt_stxn) print(usdt_txid) wait_for_confirmation(algod_client, usdt_txid) print_asset_holding(algod_client, seller_pk, USDT_asset_id)
def transferDocument(algod_client, loc_id, bol_id, seller_pk, buyer_mnemonic, carrier_mnemonic): buyer_sk = mnemonic.to_private_key(buyer_mnemonic) buyer_pk = mnemonic.to_public_key(buyer_mnemonic) carrier_sk = mnemonic.to_private_key(carrier_mnemonic) carrier_sk = mnemonic.to_pubic_key(carrier_mnemonic) txn1 = singleTransfer(buyer_pk, seller_pk, loc_id) #some params txn2 = singleTransfer(carrier_sk, buyer_pk, bol_id) #some params atomicTransfer(algod_client, txn1, txn2, buyer_sk, carrier_sk) #some params return None
def asset_transaction(passphrase, amt, rcv, asset_id, algod_client) -> dict: params = algod_client.suggested_params() add = mnemonic.to_public_key(passphrase) key = mnemonic.to_private_key(passphrase) params.flat_fee = True params.fee = 1000 unsigned_txn = AssetTransferTxn(add, params, rcv, amt, asset_id) signed = unsigned_txn.sign(key) txid = algod_client.send_transaction(signed) pmtx = wait_for_confirmation(algod_client, txid, 4) return pmtx
def get_wallet_key_pairs(passphrase): """ @params{passphrase} - 25-word mnemonic string Returns a dictionary containing the public key (account address) and private key of the wallet. @returns { 'public_key': string, 'private_key': string } """ return { 'public_key': mnemonic.to_public_key(passphrase), 'private_key': mnemonic.to_private_key(passphrase) }
def createAsset(algod_client, passphrase, html, doc_id, doc_name): # CREATE ASSET # Get network params for transactions before every transaction. params = algod_client.suggested_params() # comment these two lines if you want to use suggested params params.fee = 1000 params.flat_fee = True # Account 1 creates an asset called latinum and # sets Account 2 as the manager, reserve, freeze, and clawback address. # Asset Creation transaction account_pk = mnemonic.to_public_key(passphrase) account_sk = mnemonic.to_private_key(passphrase) txn = AssetConfigTxn(sender=account_pk, sp=params, total=1, default_frozen=False, unit_name=doc_id, asset_name=doc_name, manager=account_pk, reserve=account_pk, freeze=account_pk, clawback=account_pk, url=html, decimals=0) # Sign with secret key of creator stxn = txn.sign(account_sk) # Send the transaction to the network and retrieve the txid. txid = algod_client.send_transaction(stxn) print(txid) # Retrieve the asset ID of the newly created asset by first # ensuring that the creation transaction was confirmed, # then grabbing the asset id from the transaction. # Wait for the transaction to be confirmed wait_for_confirmation(algod_client, txid) try: # Pull account info for the creator # account_info = algod_client.account_info(accounts[1]['pk']) # get asset_id from tx # Get the new asset's information from the creator account ptx = algod_client.pending_transaction_info(txid) asset_id = ptx["asset-index"] print_created_asset(algod_client, account_pk, asset_id) print_asset_holding(algod_client, account_pk, asset_id) except Exception as e: print(e)
def send_note(): # Use sandbox or your address and token algod_address = "<your-algod-node-and-port>" algod_token = "<your-api-token>" algod_client = algod.AlgodClient(algod_token, algod_address) algod_address = "http://localhost:4001" algod_token = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" algod_client = algod.AlgodClient(algod_token, algod_address) #passphrase = "<your-25-word-mnemonic>" passphrase = "price clap dilemma swim genius fame lucky crack torch hunt maid palace ladder unlock symptom rubber scale load acoustic drop oval cabbage review abstract embark" private_key = mnemonic.to_private_key(passphrase) my_address = mnemonic.to_public_key(passphrase) print("My address: {}".format(my_address)) params = algod_client.suggested_params() # comment out the next two (2) lines to use suggested fees # params.flat_fee = True # params.fee = 1000 note = '{"firstName":"JohnChris", "lastName":"Doe"}'.encode() # note = 'JohnChris'.encode() receiver = "GD64YIY3TWGDMCNPP553DZPPR6LDUSFQOIJVFDPPXWEG3FVOJCCDBBHU5A" unsigned_txn = PaymentTxn(my_address, params, receiver, 100000, None, note) # sign transaction signed_txn = unsigned_txn.sign(private_key) # wait for confirmation try: # send transaction txid = algod_client.send_transaction(signed_txn) print("Send transaction with txID: {}".format(txid)) confirmed_txn = 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=2))) print("Decoded note: {}".format( base64.b64decode(confirmed_txn["txn"]["txn"]["note"]).decode())) person_dict = json.loads( base64.b64decode(confirmed_txn["txn"]["txn"]["note"]).decode()) print("First Name = {}".format(person_dict['firstName']))
def gettingStartedExample(): algod_address = <algod-address> algod_token = <algod-token> algod_client = algod.AlgodClient(algod_token, algod_address) passphrase = <25-word-mnemonic> private_key = mnemonic.to_private_key(passphrase) my_address = mnemonic.to_public_key(passphrase) print("My address: {}".format(my_address)) account_info = algod_client.account_info(my_address) print("Account balance: {} microAlgos".format(account_info.get('amount'))) params = algod_client.suggested_params() note = "Hello World".encode() receiver = "GD64YIY3TWGDMCNPP553DZPPR6LDUSFQOIJVFDPPXWEG3FVOJCCDBBHU5A" data = { "sender": my_address, "receiver": receiver, "fee": params.get('minFee'), "flat_fee": True, "amt": 1000000, "first": params.get('lastRound'), "last": params.get('lastRound') + 1000, "note": note, "gen": params.get('genesisID'), "gh": params.get('genesishashb64') } txn = transaction.PaymentTxn(**data) signed_txn = txn.sign(private_key) txid = signed_txn.transaction.get_txid() print("Signed transaction with txID: {}".format(txid)) algod_client.send_transaction(signed_txn) # wait for confirmation wait_for_confirmation( algod_client, txid) # Read the transction try: confirmed_txn = algod_client.transaction_info(my_address, txid) except Exception as err: print(err) print("Transaction information: {}".format(json.dumps(confirmed_txn, indent=4))) print("Decoded note: {}".format(base64.b64decode(confirmed_txn.get('noteb64')).decode()))
def claim_fund(programstr, passphrase, escrow_id, amt, payment_id, first_block, last_block, algod_client: algod_client()): add = mnemonic.to_public_key(passphrase) key = mnemonic.to_private_key(passphrase) sp = algod_client.suggested_params() sp.first = first_block sp.last = last_block sp.flat_fee = True sp.fee = 1000 txn = AssetTransferTxn(escrow_id, sp, add, amt, payment_id) t = programstr.encode() program = base64.decodebytes(t) arg = (3).to_bytes(8, 'big') lsig = LogicSig(program, args=[arg]) stxn = LogicSigTransaction(txn, lsig) tx_id = algod_client.send_transaction(stxn) wait_for_confirmation(algod_client, tx_id, 10)
def transfer_asset_holding_return_txn(algodclient, passphrase, receiver, asset_id): # transfer asset of 10 from account 1 to account 3 params = algod_client.suggested_params() # comment these two lines if you want to use suggested params params.fee = 1000 params.flat_fee = True account_pk = mnemonic.to_public_key(passphrase) account_sk = mnemonic.to_private_key(passphrase) txn = AssetTransferTxn(sender=account_pk, sp=params, receiver=receiver, amt=1, index=asset_id) return txn
def create_fund_accounts(): # For ease of reference, add account public and private keys to an accounts dict. print("--------------------------------------------") print("Creating Alice and Bob's accounts...") mnemonics = [] mnemonics.append(create_account()) mnemonics.append(create_account(False)) accounts = {} counter = 0 for m in mnemonics: accounts[counter] = {} accounts[counter]['pk'] = mnemonic.to_public_key(m) accounts[counter]['sk'] = mnemonic.to_private_key(m) counter += 1 return accounts
def purchase_bond(programstr, escrow_id, passphrase, amt, payment_id, par, interest_id, par_id, total_payments, algod_client: algod_client(), first_block, last_block): add = mnemonic.to_public_key(passphrase) key = mnemonic.to_private_key(passphrase) sp = algod_client.suggested_params() sp.first = first_block sp.last = last_block sp.flat_fee = True sp.fee = 1000 print("--------------------------------------------") print("Opt-in the buyer account for interest and par token......") txn0_1 = AssetTransferTxn(add, sp, add, 0, interest_id) txn0_2 = AssetTransferTxn(add, sp, add, 0, par_id) sign0_1 = txn0_1.sign(key) sign0_2 = txn0_2.sign(key) txn0_1_id = algod_client.send_transaction(sign0_1) wait_for_confirmation(algod_client, txn0_1_id, 5) print("Successfully opt-in") print("--------------------------------------------") print("--------------------------------------------") print("Bundling purchase transactions and submitting......") txn0_2_id = algod_client.send_transaction(sign0_2) wait_for_confirmation(algod_client, txn0_2_id, 5) txn1 = AssetTransferTxn(add, sp, escrow_id, amt * par, payment_id) txn2 = AssetTransferTxn(escrow_id, sp, add, amt, par_id) txn3 = AssetTransferTxn(escrow_id, sp, add, amt * total_payments, interest_id) t = programstr.encode() program = base64.decodebytes(t) arg = (3).to_bytes(8, 'big') lsig = LogicSig(program, args=[arg]) grp_id = calculate_group_id([txn1, txn2, txn3]) txn1.group = grp_id txn2.group = grp_id txn3.group = grp_id stxn1 = txn1.sign(key) stxn2 = LogicSigTransaction(txn2, lsig) stxn3 = LogicSigTransaction(txn3, lsig) signed_group = [stxn1, stxn2, stxn3] tx_id = algod_client.send_transactions(signed_group) wait_for_confirmation(algod_client, tx_id, 200) print("Successfulley commited transaction!") print("--------------------------------------------")
def __init__(self): self.algod_address = "https://testnet-algorand.api.purestake.io/ps2" self.algod_token = "zLAOcinLq31BhPezSnHQL3NF7qBwHtku6XwN8igq" headers = { "X-Api-key": self.algod_token, # "X-Algo-API-Token": "asdf" } 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" self.private_key = mnemonic.to_private_key(passphrase) self.my_address = mnemonic.to_public_key(passphrase) print("My address: {}".format(self.my_address)) self.algod_client = algod.AlgodClient(self.algod_token, self.algod_address, headers) self.status = self.algod_client.status() # print(json.dumps(self.status, indent=4)) self.account_info = self.algod_client.account_info(self.my_address) print("Account balance: {} microAlgos".format(self.account_info.get('amount')))
def send_note(): algod_address = "http://localhost:4001" algod_token = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" algod_client = algod.AlgodClient(algod_token, algod_address) passphrase = "" private_key = mnemonic.to_private_key(passphrase) my_address = mnemonic.to_public_key(passphrase) print(f'My address: {my_address}') params = algod_client.suggested_params() # comment out the next two (2) lines to use suggested fees params.flat_fee = True params.fee = 1000 json_note = parse_into_json() note = json_note.encode() receiver = "" unsigned_txn = PaymentTxn(my_address, params, receiver, 100000, None, note) # sign transaction signed_txn = unsigned_txn.sign(private_key) # sign transaction signed_txn = unsigned_txn.sign(private_key) # send transaction txid = algod_client.send_transaction(signed_txn) print("Send transaction with txID: {}".format(txid)) # wait for confirmation try: confirmed_txn = 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=2))) print("Decoded note: {}".format( base64.b64decode(confirmed_txn["txn"]["txn"]["note"]).decode()))
def getting_started_example(): algod_address = "http://localhost:4001" algod_token = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" algod_client = algod.AlgodClient(algod_token, algod_address) passphrase = "price clap dilemma swim genius fame lucky crack torch hunt maid palace ladder unlock symptom rubber scale load acoustic drop oval cabbage review abstract embark" # generate a public/private key pair private_key = mnemonic.to_private_key(passphrase) my_address = mnemonic.to_public_key(passphrase) print("My address: {}".format(my_address)) account_info = algod_client.account_info(my_address) print("Account balance: {} microAlgos".format(account_info.get('amount'))) # build 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 = "GD64YIY3TWGDMCNPP553DZPPR6LDUSFQOIJVFDPPXWEG3FVOJCCDBBHU5A" note = "Hello World".encode() unsigned_txn = PaymentTxn(my_address, params, receiver, 1000000, None, note) # sign transaction signed_txn = unsigned_txn.sign(mnemonic.to_private_key(passphrase)) txid = algod_client.send_transaction(signed_txn) print("Signed transaction with txID: {}".format(txid)) # wait for confirmation try: confirmed_txn = wait_for_confirmation(algod_client, txid, 4) except Exception as err: print(err) return print("Transaction information: {}".format( json.dumps(confirmed_txn, indent=4))) print("Decoded note: {}".format( base64.b64decode(confirmed_txn["txn"]["txn"]["note"]).decode()))
def activate_account(asset_id, user_memonic): # Check if asset_id is in account 3's asset holdings prior # to opt-in params = algod_client.suggested_params() # comment these two lines if you want to use suggested params params.fee = 0 params.flat_fee = False params.min_fee = 0 account = { 'pk': mnemonic.to_public_key(user_memonic), 'sk': mnemonic.to_private_key(user_memonic) } account_info = algod_client.account_info(account['pk']) holding = None idx = 0 for my_account_info in account_info['assets']: scrutinized_asset = account_info['assets'][idx] idx = idx + 1 if (scrutinized_asset['asset-id'] == asset_id): holding = True break if not holding: # Use the AssetTransferTxn class to transfer assets and opt-in txn = AssetTransferTxn( sender=account['pk'], sp=params, receiver=account["pk"], amt=0, index=asset_id) stxn = txn.sign(account['sk']) txid = algod_client.send_transaction(stxn) print(txid) # Wait for the transaction to be confirmed wait_for_confirmation(algod_client, txid) # Now check the asset holding for that account. # This should now show a holding with a balance of 0. print_asset_holding(algod_client, account['pk'], asset_id)
def getting_started_example(): algod_address = "http://localhost:4001" algod_token = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" algod_client = algod.AlgodClient(algod_token, algod_address) passphrase = "Your 25-word mnemonic generated and displayed above" # generate a public/private key pair private_key = mnemonic.to_private_key(passphrase) my_address = mnemonic.to_public_key(passphrase) print("My address: {}".format(my_address)) account_info = algod_client.account_info(my_address) print("Account balance: {} microAlgos".format(account_info.get('amount'))) # build 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 = "GD64YIY3TWGDMCNPP553DZPPR6LDUSFQOIJVFDPPXWEG3FVOJCCDBBHU5A" note = "Hello World".encode() unsigned_txn = PaymentTxn(my_address, params, receiver, 1000000, None, note) # sign transaction signed_txn = unsigned_txn.sign(mnemonic.to_private_key(passphrase)) txid = algod_client.send_transaction(signed_txn) print("Signed transaction with txID: {}".format(txid)) # wait for confirmation wait_for_confirmation(algod_client, txid) # read transction try: confirmed_txn = algod_client.pending_transaction_info(txid) except Exception as err: print(err) print("Transaction information: {}".format(json.dumps(confirmed_txn, indent=4))) print("Decoded note: {}".format(base64.b64decode(confirmed_txn["txn"]["txn"]["note"]).decode()))
def claim_par(programstr, escrow_id, passphrase, amt, par, payment_id, par_id, first_block, last_block, algod_client): add = mnemonic.to_public_key(passphrase) key = mnemonic.to_private_key(passphrase) sp = algod_client.suggested_params() sp.first = first_block sp.last = last_block sp.flat_fee = True sp.fee = 1000 txn1 = AssetTransferTxn(add, sp, escrow_id, amt, par_id) txn2 = AssetTransferTxn(escrow_id, sp, add, amt * par, payment_id) t = programstr.encode() program = base64.decodebytes(t) arg = (5).to_bytes(8, 'big') lsig = LogicSig(program, args=[arg]) grp_id = calculate_group_id([txn1, txn2]) txn1.group = grp_id txn2.group = grp_id stxn1 = txn1.sign(key) stxn2 = LogicSigTransaction(txn2, lsig) signed_group = [stxn1, stxn2] tx_id = algod_client.send_transactions(signed_group) wait_for_confirmation(algod_client, tx_id, 10)
def transfer_asset(asset_id, user_memonic, amount): account = { 'pk': mnemonic.to_public_key(user_memonic), 'sk': mnemonic.to_private_key(user_memonic) } # transfer asset of 10 from account 1 to account 3 params = algod_client.suggested_params() # comment these two lines if you want to use suggested params params.fee = 1 params.flat_fee = True txn = AssetTransferTxn( sender=accounts[1]['pk'], sp=params, receiver=account["pk"], amt=int(amount), index=asset_id) stxn = txn.sign(accounts[1]['sk']) txid = algod_client.send_transaction(stxn) print(txid) # Wait for the transaction to be confirmed wait_for_confirmation(algod_client, txid) # The balance should now be 10. print_asset_holding(algod_client, account['pk'], asset_id)
def par_token_issuance(algod_client, passphrase, proj_name, vol, url) -> (int, int): """ Issues Token for Par Value Payment returns an AssetConfigTxn() """ # sets basic transaction parameter params = algod_client.suggested_params() params.fee = 1000 params.flat_fee = True address = mnemonic.to_public_key(passphrase) key = mnemonic.to_private_key(passphrase) # configure asset basics txn = AssetConfigTxn(sender=address, sp=params, total=vol, default_frozen=False, unit_name=proj_name[0] + "PC", asset_name=proj_name + "Par", manager=address, reserve=address, freeze=address, clawback=address, url=url, decimals=0) signed = txn.sign(key) txid = algod_client.send_transaction(signed) wait_for_confirmation(algod_client, txid, 4) try: ptx = algod_client.pending_transaction_info(txid) asset_id = ptx["asset-index"] return txid, asset_id except Exception as e: print(e)