DEV Community: Syed Aabis Akhtar

How to Airdrop yourself SOL tokens on Solana devnet using Python

Syed Aabis Akhtar — Sat, 19 Feb 2022 15:40:20 +0000

This is going to be a pretty quick tutorial, we are going to see how we can airdrop ourselves some SOL tokens on devnet using Python. So let's get started!

First of all, you would need Python 3.6+ installed, now install Solathon, which is an easy to use and powerful Python SDK for Solana:

pip install solathon

Now, create a main.py file and add the following code:

from solathon import Client

client = Client("https://api.devnet.solana.com")

Here, we are simply initializing a devnet client, now we would need to specify some variables, have a look into the following:

from solathon import PublicKey
from solathon.utils import sol_to_lamport

public_key = PublicKey("your_public_key")
amount = sol_to_lamport(1)

Here we are creating our public key object using Solathon's PublicKey class by passing our wallet's public key as a string; then we are specifying the amount we wish to airdrop ourselves. Note that we are using sol_to_lamport function from Solathon; that is because the standard unit for amounts on the Solana blockchain is lamports. However, since we are more familiar with using SOL token, we can use this function for easy conversions. Another thing to remember is that you can airdrop yourself 2 SOLs at once.

Now comes the last part, we will use the request_airdrop method from Client to get ourselves one SOL:

response = client.request_airdrop(public_key, amount)
print(response)

And that's it! Here is the full code:

from solathon import Client, PublicKey
from solathon.utils import sol_to_lamport

client = Client("https://api.devnet.solana.com")
public_key = PublicKey("your_public_key")
amount = sol_to_lamport(1)

response = client.request_airdrop(public_key, amount)
print(response)

As you can see, it's quite easy to airdrop yourself some SOL tokens using Python and Solathon SDK. Hopefully this tutorial was helpful and you learned something new; feel free to ask questions if any. See you soon next time! Thanks for reading.

How to send Solana transactions using Python ✨

Syed Aabis Akhtar — Thu, 17 Feb 2022 19:30:12 +0000

In this tutorial, we are going to be seeing how we can send a transaction in the Solana blockchain using Python!

For this, you do not need to know any complexity or what happens behind the scenes. We will be using Solathon, which is an easy to use, feature rich SDK for Solana in Python.

Make sure you have Python 3.7 or above installed, now install the package using the following command:

pip install solathon

First of all we would need to create a client, which we will use to interact with the Solana's JSON RPC. For testing purposes, we will be using devnet as it doesn't require you to have real SOL balance. The following code creates a client on devnet along with all the imports we will be requiring later on:

from solathon.core.instructions import transfer
from solathon import Client, Transaction, PublicKey, Keypair

client = Client("https://api.devnet.solana.com")

Now, we would need to define three things; first of all, the account which is sending the transaction, second is the account which will receive the transaction, and third is the amount of money we want to send in lamports (which is the standard unit for amounts in transactions on Solana blockchain). Have a look at the code below:

sender = Keypair.from_private_key("you_private_key_here")
receiver = PublicKey("receiver_public_key")
amount = 100

Here, the sender needs to be a keypair, which is a combination of public key and private key, you would need to get your private key from your wallet in order to initialize your Keypair object. Then we need the public key of the account whom we wish to send the transaction to, finally we have the amount which we want to transfer in lamports. You can use the sol_to_lamport function provided by Solathon for easy conversions.

Now, each transaction requires you to have certain instructions defined which needs to be executed, here we just need one instruction and that is transfer:

instruction = transfer(
        from_public_key=sender.public_key,
        to_public_key=receiver, 
        lamports=100
    )

Now, we need to initialize our transaction object with our list of instructions and signers (which will be only the sender in this case):

transaction = Transaction(instructions=[instruction], signers=[sender])

Finally we can send this transaction and print the results:

result = client.send_transaction(transaction)
print("Transaction result: ", result)

Here is the entire code:

from solathon.core.instructions import transfer
from solathon import Client, Transaction, PublicKey, Keypair

client = Client("https://api.devnet.solana.com")

sender = Keypair.from_private_key("your_private_key")
receiver = PublicKey("receiver_public_key")
amount = 100  

instruction = transfer(
        from_public_key=sender.public_key,
        to_public_key=receiver, 
        lamports=100
    )

transaction = Transaction(instructions=[instruction], signers=[sender])

result = client.send_transaction(transaction)
print("Transaction response: ", result)

You can also check out the official documentation for more details: Solathon docs for sending transaction

How easy it that? Hope so I was able to make things clear and the tutorial was helpful, if there is something which still confuses you or you have any query in general, feel free to ask any questions. See you soon!

Web3 authentication on Solana using Python⚡

Syed Aabis Akhtar — Sun, 13 Feb 2022 18:28:52 +0000

So you want to implement authentication in your Python backend in Web3 style? Well, you are in the right place! I'll try my best to explain the whole Web3 authentication process and how you can implement it using Python on your Solana dApp.

How does Web3 authentication work?

Like Web2, there are many authentication methods in Web3 as well, since Web3 is in it's early stages, there isn't any "official" or approved authentication system. Developers have implemented authentication in their dApps using very smart methods, the one we are going to see today is very easy yet effective way to achieve it. The image below gives a rough idea of how the process looks like.

User does any action which requires authentication, for example updating their on chain profile.
Using @solana/web3.js or vanilla JavaScript, we will ask the user to sign a message through their wallet in the frontend; the message can be their public key itself to keep things simpler.
After a user signs the message, just like Web2, we can send the authentication information through headers; for this we would need to send both the public key and signature to authorize the user.
Using a signature decoding function, we will verify whether the signature received is signed by the public key or not.
If the signature is valid, we will run the auth-related action, which is updating the profile in this case.
After that, just like JWT tokens we can store the signature in localStorage for future use, so that a user won't need to sign the message each time when they perform any auth-related action.

Python implementation

I'll be using FastAPI as my backend framework for this implementation, however you can do this in pretty much any framework. First of all, let's install FastAPI and Solathon, which is an easy to use and feature rich SDK for Solana in Python

pip install solathon && pip install fastapi

Now, create a main.py file and add the following code to initialize a FastAPI application:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def root() -> None:
    return {"message": "Web3 rocks!"}

Now let's create a simple API which returns our public key if the signature is valid, we will pass it for now:

@app.get("/verify_signature")
def verify_signature() -> None:
    pass

Now comes the authentication part, Solathon is a very powerful library with a lot of features which you can use to develop Solana applications in Python, however for authentication only one function from the library is required, let's import it:

from solathon.utils import verify_signature

Now, we need to get our public key and signature from the API request headers, for that we would need to import Request object from fastapi and pass it as the first parameter:

from fastapi import Request

@app.get("/verify_signature")
def verify_signature(request: Request) -> None:
    pass

Now, let's authenticate our request:

@app.get("/verify_signature")
def verify_signature(request: Request) -> None:
    public_key = request.headers.get("public_key", None)
    # This can be passed in the "Authorization" header as well
    signature = request.headers.get("signature", None)
    try:
        verify_signature(public_key, signature)
    except:
        return {"error": "Unauthorized"}

    return {"message": public_key}

First we are getting our public key and signature from headers, the signature will be a 64 items long array of integers. Then we are running the verify_signature function which we imported earlier, the function returns nothing if the signature is valid, however if the signature is invalid, then it raises a nacl.exceptions.BadSignatureError exception, which we can catch using try and except block and return the error message in our API. Further more we can return a 401 HTTP status code as well.

That's it! I hope this post was helpful and I was able to teach Web3 authentication properly so that you can implement it in your next Solana backend in Python.