Once logged in, you will be able to access a different API key in your account.

Here you will see your API key at the top of the screen. You will need to copy this key to access the PureStake API service.

Step 3: Set Configuration Values for the PureStake API

First, you need to set the default configuration values for the PureStake API. This process differs from the example posted by Algorand in that the token must be set as a dict.

To do that, enter the following:

1. import json

2. from algosdk.v2client import algod

3. from algosdk import mnemonic

4. from algosdk import transaction

5. algod_token = 'YOUR API KEY HERE'

6. algod_address = 'https://testnet-algorand.api.purestake.io/ps2'

7. purestake_token = {'X-Api-key': algod_token}

• In algod_tokan you need to write your Purestake API Key
• In Algod_address you need to write the IP address which API endpoints can be accessed

Step 4: Recover Account

Now you’ll need to recover your account using your mnemonic.

Important Note: Mnemonics control your account. Never share them or store them insecurely. The code below is for demonstration purposes only.

1. mnemonic_phrase = "YOUR MNEMONIC HERE";
2. account_private_key = mnemonic.to_private_key(mnemonic_phrase)
3. account_public_key = mnemonic.to_public_key(mnemonic_phrase)

• In mnemonic_phrase you need to write your Account Passphrase

Checking Algorand Wallet Balance

1. account_info = algod_client.account_info(account_public_key)
2. print("Account balance: {} microAlgos".format(account_info.get('amount')))

• We can get the account information of a wallet by using the command account_info. It will result in a JSON output.

Since only need to print the amount value, we will use get('amount'). Output will be

1. #Account Balance
2. Account balance: 1997000 microAlgos

Step 5: Create the Client

To instantiate the client, enter:

1. algodclient = algod.AlgodClient(algod_token, algod_address, headers=purestake_token)

Step 6: Get and Set Transaction Parameters

Get the transaction parameters from the blockchain using the client object and set the amount and destination address.

1. params = algodclient.suggested_params()

2. gh = params.gh

3. first_valid_round = params.first

4. last_valid_round = params.last

5. fee = params.min_fee

6. send_amount = 10

7. note = "Hello World".encode()

8. existing_account = account_public_key

9. send_to_address = 'ICO3XHZSIZTQ5N32VHZ6ORF3QG7QFJNHTHNECCYB4KNUKT725GP5NLQGUU'

• I have kept flat_fee to be the minimum possible.
• I have kept the transaction fee and amount to be sent as 1000 microAlgos
• I have kept the message to be sent with the transaction as "Hello World", and have encoded it before transmitting it.

You can change all values according to your need.

Step 7: Create and Sign Transaction

Create a new transaction using the parameters defined above and sign it.

1. tx = transaction.PaymentTxn(existing_account, fee, first_valid_round, last_valid_round, gh, send_to_address, send_amount, flat_fee=True)
2. signed_tx = tx.sign(account_private_key)

Step 8: Include Verification Method

After the transaction is completed and sent , this method is called to verify that the transaction is included in the blockchain .

1. Function from Algorand Inc. - utility for waiting on a transaction confirmation

2. def wait_for_confirmation(client, txid):

3.  last\_round = client.status().get('last-round')  
   

4.  txinfo = client.pending\_transaction\_info(txid)  
   

5.  while not (txinfo.get('confirmed-round') and txinfo.get('confirmed-round') > 0):  
   

6.      print('Waiting for confirmation')  
   

7.      last\_round += 1  
   

8.      client.status\_after\_block(last\_round)  
   

9.      txinfo = client.pending\_transaction\_info(txid)  
   

10.  print('Transaction confirmed in round', txinfo.get('confirmed-round'))  
    

11.  return txinfo
    

Step 9: Submit and Verify Transaction

Finally , the signed transaction is sent to the blockchain.

1. try:

2.  tx\_confirm = algodclient.send\_transaction(signed\_tx)  
   

3.  print('Transaction sent with ID', signed\_tx.transaction.get\_txid())  
   

4.  wait\_for\_confirmation(algodclient, txid=signed\_tx.transaction.get\_txid())  
   

5. except Exception as e:

6.  print(e)
   

In the above code, we are waiting for the transaction to get submitted and verified from the testnet. I have kept it under try-except so as to catch any error or exception which may cause hindrance.

You should see a response similar to the following:

1. Transaction sent with ID UZCV4JQB2NJ7USKXZIG755TQMIU55BUTMFOYRD4QVYWVOT5GOWBQ
2. Waiting for confirmation
3. Transaction confirmed in round 21443800

Step 10: Run All of the Code Together

If you’d rather just drop in the code in its entirety, copy it below. You will need to enter your API key, mnemonic and other details to work properly.

1. import json

2. from algosdk.v2client import algod

3. from algosdk import mnemonic

4. from algosdk import transaction

5. Function from Algorand Inc.

6. def wait_for_confirmation(client, txid):

7.  last\_round = client.status().get('last-round')  
   

8.  txinfo = client.pending\_transaction\_info(txid)  
   

9.  while not (txinfo.get('confirmed-round') and txinfo.get('confirmed-round') > 0):  
   

10.      print('Waiting for confirmation')  
    

11.      last\_round += 1  
    

12.      client.status\_after\_block(last\_round)  
    

13.      txinfo = client.pending\_transaction\_info(txid)  
    

14.  print('Transaction confirmed in round', txinfo.get('confirmed-round'))  
    

15.  return txinfo
    

16. Setup HTTP client w/guest key provided by PureStake

17. algod_token = 'YOUR API KEY HERE'

18. algod_address = 'https://testnet-algorand.api.purestake.io/ps2'

19. purestake_token = {'X-Api-key': algod_token}

20. Initalize throw-away account for this example - check that is has funds before running script

21. mnemonic_phrase = 'YOUR MNEMONIC HERE';

22. account_private_key = mnemonic.to_private_key(mnemonic_phrase)

23. account_public_key = mnemonic.to_public_key(mnemonic_phrase)

24. algodclient = algod.AlgodClient(algod_token, algod_address, headers=purestake_token)

25. #Account Balance

26. account_info = algod_client.account_info(account_public_key)

27. print("Account balance: {} microAlgos".format(account_info.get('amount')))

28. get suggested parameters from Algod

29. params = algodclient.suggested_params()

30. gh = params.gh

31. first_valid_round = params.first

32. last_valid_round = params.last

33. fee = params.min_fee

34. send_amount = 10

35. existing_account = account_public_key

36. send_to_address = 'ICO3XHZSIZTQ5N32VHZ6ORF3QG7QFJNHTHNECCYB4KNUKT725GP5NLQGUU'

37. Create and sign transaction

38. tx = transaction.PaymentTxn(existing_account, fee, first_valid_round, last_valid_round, gh, send_to_address, send_amount, flat_fee=True)

39. signed_tx = tx.sign(account_private_key)

40. try:

41.  tx\_confirm = algodclient.send\_transaction(signed\_tx)  
    

42.  print('Transaction sent with ID', signed\_tx.transaction.get\_txid())  
    

43.  wait\_for\_confirmation(algodclient, txid=signed\_tx.transaction.get\_txid())  
    

44. except Exception as e:

45.  print(e)
    

Conclusion

Thank you for reading the article, hope you got to know about PureStake Algorand, and how we can use PureStake Algorand Python SDK to create a simple application.

We will continue the Algorand series.

How to Use Algorand Python SDK

In this article, we will learn how we can use Algorand Python SDK to create a simple application.