DEV Community

Gabriel Saldanha
Gabriel Saldanha

Posted on • Updated on

Deploy a Smart Contract on Ethereum with Python, Truffle and web3py

In this tutorial, we'll write a simple smart contract, deploy it to a personal Ethereum blockchain, and call the contract from a Python script.

What you need to have installed before we proceed:

  • Python3 v3.5.3 or later, I had some issues using version 3.8 then switched to 3.5.3;
  • NodeJS v8.9.4 or later (for installing truffle);

The full project code is available at GitHub


  1. Project Setup
  2. Writing the smart contract
  3. Deploying smart contract to the blockchain
  4. Calling the deployed contract

1. Project setup

First, let's create a folder for the project:

$ mkdir hello-eth
$ cd hello-eth
Enter fullscreen mode Exit fullscreen mode

Inside hello-eth folder, install truffle:

npm install truffle
# You should something like this once the installation process is finished
+ truffle@5.1.25
Enter fullscreen mode Exit fullscreen mode

We will use the truffle CLI tool to initialize an empty smart contract project:

$ ./node_modules/.bin/truffle init
# if truffle was installed globally (npm install -g truffle): $ truffle init
Enter fullscreen mode Exit fullscreen mode

The above command will create the following project structure:

  • contracts/: Directory for Solidity contracts source code (.sol files).
  • migrations/: Directory for contracts migration files.
  • test/: Directory for test files. Won't be covered in this tutorial.
  • truffle.js: Truffle configuration file.

contracts/ and migrations/ folders will already contain a Migration contract and its deploy script (1_initial_migration.js). This contract is used by truffle to keep track of the migrations of our contracts. It won't be covered in this tutorial, so don't worry about it.

2. Writing the smart contract

Yes, I'll use the Hello World example. Create a file called HelloWorld.sol inside contracts/ folder and add the following content to it:

pragma solidity >= 0.5.0 < 0.7.0;

contract HelloWorld {
    function sayHello() public pure returns (string memory) {
        return 'Hello World!';
Enter fullscreen mode Exit fullscreen mode

From the project root folder, use truffle to compile the contract:

$ ./node_modules/.bin/truffle compile  # or just truffle compile if installed globally...
Enter fullscreen mode Exit fullscreen mode

It will output the compiled contract HelloWorld.sol as HelloWorld.json inside build/contracts/ folder.

We now have a compiled contract and are ready to deploy it to our running to the (local) blockchain.

3. Deploying smart contract to the blockchain

To deploy our smart contract to the blockchain we first need:

  1. a migration script;
  2. a blockchain to deploy the contract to;

For the migration script, create a file named 2_deploy_contract.js inside migrations/ folder and add the following content to it:

var HelloWorld = artifacts.require("HelloWorld");

module.exports = function(deployer) {
Enter fullscreen mode Exit fullscreen mode

Truffle suite contains a personal blockchain that we can use for testing purposes. Open your terminal and run:

$ truffle develop
Enter fullscreen mode Exit fullscreen mode

You should see an output similar to the following:

Truffle Develop started at

(0) 0xdfb772fba7631b5bfde93cc3e2b0e488d1a17b2a
(9) 0x974779d6a98264043e8bb1c8b0cf93d9c7141a29

Private Keys:

Enter fullscreen mode Exit fullscreen mode

We can now migrate our contract, which calls each migration in migrations/ (in order), deploying the contracts to the blockchain.

truffle(develop)> migrate
Starting migrations...

   Deploying 'HelloWorld'
   > transaction hash:    0xddc3dd045a7b6f70063303ff534d07e93c1dcb7a0a6c15e42fe281c7d2ab53e8
   > Blocks: 0            Seconds: 0
   > contract address:    0xb7afC8dB8EEf302cd30553B39cEa0599093FDE3C
Enter fullscreen mode Exit fullscreen mode

contract address is the address on the Ethereum network that hosts this contract instance.
Sweet! We now have a Smart Contract deployed on our personal Ethereum blockchain. Next step is call it from a Python script.

4. Calling the deployed contract

Under the project root folder (hello-eth/) create a file named with the following content (pay attention to the comments explaining the script):

import json
from web3 import Web3, HTTPProvider

# truffle development blockchain address
blockchain_address = ''
# Client instance to interact with the blockchain
web3 = Web3(HTTPProvider(blockchain_address))
# Set the default account (so we don't need to set the "from" for every transaction call)
web3.eth.defaultAccount = web3.eth.accounts[0]

# Path to the compiled contract JSON file
compiled_contract_path = 'build/contracts/HelloWorld.json'
# Deployed contract address (see `migrate` command output: `contract address`)
deployed_contract_address = '0xb7afC8dB8EEf302cd30553B39cEa0599093FDE3C'

with open(compiled_contract_path) as file:
    contract_json = json.load(file)  # load contract info as JSON
    contract_abi = contract_json['abi']  # fetch contract's abi - necessary to call its functions

# Fetch deployed contract reference
contract = web3.eth.contract(address=deployed_contract_address, abi=contract_abi)

# Call contract function (this is not persisted to the blockchain)
message = contract.functions.sayHello().call()

Enter fullscreen mode Exit fullscreen mode

Now, execute the following commands in your terminal:

$ pip3 install web3
$ python3
> 'Hello World!'
Enter fullscreen mode Exit fullscreen mode

Wrapping up

In this tutorial, you learned how to:

  • Write a simple Smart Contract in Solidity;
  • Create a personal Ethereum Blockchain for tests and development;
  • Deploy a contract to the blockchain using truffle;
  • Call the contract function from a Python application.

I will write two follow-up posts in the next few days:

  • how to persist data to the blockchain via a Web API using Flask;
  • how to use Ganache as the personal blockchain provider (which has a nice GUI to inspect transactions);

If you'd like to be notified when that comes up, make sure to follow me on

Top comments (0)