Smart Contract Development Using Python

The rise of blockchain tech has totally changed scenarios of how we handle digital assets and trade value. It's like this whole new way of doing things where everything is decentralized, meaning it's all about trust, transparency, and top-notch security. At the heart of this transformative technology lies the concept of smart contracts. These are self-executing programs on a blockchain that can make agreements happen without any middlemen getting in the way. In this article, we give you a step-by-step guide to smart contract development using Python and Brownie.

Smart Contracts

Smart contracts automatically execute and enforce the terms of the contract written in the form of code when predefined conditions are met. Since they operate on a blockchain, they benefit from the immutability and decentralization of the underlying technology. This means that once a smart contract is deployed, its code and the outcomes of its execution are recorded on the blockchain and cannot be altered by any party.

Smart Contract Development

When starting smart contract development, developers have two popular options: Python and JavaScript. Both languages offer unique advantages, but let's focus on Python for now.

Python, known for its versatility and widespread adoption, has become a compelling choice for smart contract development. Its clear and concise syntax, coupled with a rich set of libraries and an active community, makes it an ideal tool for both beginners and seasoned developers entering the world of blockchain technology. As we delve into smart contract development, Python will be our guide, providing an accessible and powerful entry point into the decentralized landscape.

For developing and testing smart contracts on Python, we have selected Brownie, a popular Python-based framework specifically designed for this purpose. Its ease of use and popularity among Python developers make it an ideal choice for streamlining smart contract development.

Also, Discover | The Increasing Inevitability of Hybrid Smart Contract Development

Prerequisites

python3 version 3.6 or greater
ganache-cli - version 6.12.2 or above

Steps Involved in Smart Contract Development using Python

Installation

To install Brownie the best way is to use pipx, which is similar to "JavaScript's npx" for Python.

pipx install eth-brownie

Once installation is complete, type "brownie" in the console to verify that it worked

Setting up a Project

To start using Brownie first you need to set up a project directory and Brownie's CLI tool provides this functionality via the following command:

$ brownie init

For now, we will use one of Brownie's features named Brownie mixes. Brownie mixes are ready-made templates that you can use as a starting point for your project or as a tutorial. You can find mixes here https://github.com/brownie-mix/

$ brownie bake token

After running this command a directory named token will be created. You can open it using any editor of your choice. There you will see the following folder structure:

The folders for the current scope of learning are the following:

contracts/: All smart contracts are created here
interfaces/: IAll smart contracts interfaces are created here
scripts/: Scripts for deployment and interaction with smart contracts
tests/: Scripts for testing the smart contracts developed

The following directories are used internally by Brownie to manage the project:

build/: Project data such as compiler artifacts and unit test results
reports/: JSON report files for use in the GUI

To Compile your Project:

$ brownie compile

You will see the following output:

Brownie - Python development framework for Ethereum

Compiling contracts...
Optimizer: Enabled  Runs: 200
- Token.sol...
- SafeMath.sol...
Brownie project has been compiled at token/build/contracts

We can change the compiler version and other settings by editing the config file i.e. brownie.config.yaml

Smart Contract Deployment using Scripts

Once a project is ready to be deployed, Brownie can be used to handle the deployments.

Before understanding the deployment process we need to understand how wallets are managed in Brownie. The Accounts container (available as accounts or just a) allows you to access all your local accounts or wallets. Each individual account is represented by an Account object that can perform actions such as querying a balance or sending ETH.

To add a new account via private key:

$ brownie accounts new <id>

Here <id> is the name of the wallet that is going to be used. After running this command you will be asked to input the private key and password to access the account later. Then, the account will be available as <id>.

Creating a Deployment Script

First of all, we need to create an Account object by unlocking the account using Accounts.load() function and passing the <id>
Then we can write the code to deploy smart contracts using the Account loaded.

from brownie import Token, accounts

def main():
    acct = accounts.load('deployment_account')
    Token.deploy("My Real Token", "RLT", 18, 1e28, {'from': acct})

Running the deployment script

$ brownie run deploy.py --network <network id>

In order to execute your script in a live environment, you must include the --network flag in the command line. You can use network ids defined in brownie-confing.yaml

Please note that transactions are not confirmed immediately on live blockchains the script will take some time to complete.

Verifying Deployment Source Code

Brownie allows automatic source code verification for solidity contracts on all networks supported by etherscan. To verify a contract while deploying it, add the publish_source=True argument in the deploy function

Token.deploy("My Real Token", "RLT", 18, 1e28, {'from': acct}, publish_source=True)

Verifying already deployed contracts is also supported. It works only if the compiler settings are identical to the deployed contracts

token = Token.at("0x114A107C1931de1d5023594B14fc19d077FC4dfD")
Token.publish_source(token)

Check It Out | Smart Contract Development with Hyperledger Fabric Blockchain

Summing Up

This introductory guide has equipped you with the basic knowledge and tools to begin your smart contract development journey using Python and Brownie. Remember, this guide is just the beginning; it's like having a map to start your adventure. To truly become a smart contract expert, you'll need to continue exploring and learning. For your next step, you can checkout the official Brownie documentation.

Looking for smart contract development services? Connect with our smart contract developers to get started.