This tutorial will be exploring the potential of combining IoT and blockchain using simple Python directly on microcontrollers, thanks to Zerynth tools.
In particular, the Zerynth Ethereum library allows microcontrollers, the heart of IoT solutions, to generate and sign Ethereum transactions in a few lines of Python. This empowers IoT developers to easily connect to the Ethereum blockchain, use Smart Contracts and seamlessly integrate IoT devices with DApps (decentralized applications).
A high-level interface is made available with this library, granting to anyone the possibility to start using blockchain and secure any kind of IoT application.
Having the possibility to generate, sign and send transactions from the inside of a microcontroller enables any device capable of running the cryptography algorithms to directly take advantage of smart contracts, removing centralized gateways and points of failure.
This can be applied to many different fields and increments trust from consumers and third parties.
For example, a supply chain can be monitored from the inside removing any single central authority storing the data and offering to final customers a certificate of the process goods are gone through. Going further, it can enable the economy of things, i.e. objects that can actually receive payments and offer services in exchange on-demand – like smart electricity meters offering a completely transparent service for the users.
For better understand the advantages of using Blockchain with Embedded Systems, take a look at this tech talk by BARR Group.
The Zerynth Ethereum module – open source Python library for Ethereum and Smart Contracts
The Zerynth Ethereum library takes advantage of the JSON-RPC interface available to interact with an Ethereum node and sending transaction. It also implements the RLP (Recursive Length Prefix) encoding scheme, and expose some high-level API to call the more common methods (e.g. getting the balance of an address). For the hashing and signatures, the Zerynth crypto module is used.
The main class available is RPC. From an RPC object, it’s possible to fetch network status information and make transactions. To get a higher level interface there are also two companion classes: Transaction and Contract. The first helps to build a correct signed transaction ready to be sent, and the latter can be used to register a smart contract and its methods for calling them later.
In the following examples, both of these are shown in a real Ethereum test network.
Description of the examples: “Simple Transaction” and “Dice Game”
There are two examples available, showing how to make a simple transaction and how to configure and use a real smart contract.
In both examples the Ropsten test network is used, so no real value is actually being transferred, but it acts exactly the same way that it would be in the real Ethereum network.
Example 1: “Simple Transaction”
This example shows how to transfer value (Ether) from an address to another through an Ethereum transaction. After signing and sending the transaction it’s possible to use an external tool like https://ropsten.etherscan.io to monitor the status and the validity of it.
This example shows how to call some smart contract functions, get the return value, or transfer Ether to a payable function.
The smart contract used in this example act as a shooter for a virtual 20-faces dice.
A player can ask the shooter to roll the dice paying any amount (with a minimum 5 Wei) using the bet function.
After rolling the dice, if the sum of the number is greater or equal to 14, the player wins the jackpot. In any case, his bet becomes part of the jackpot itself.
Note: the smart contract source code it’s included in the example folder, that will be created after the cloning of the example via Zerynth Studio. A live version of the contract can be found on the Ropsten network at this address: 0xf7a270b24d2859002c0f414b0a0c97e4c794f5cc.
The following steps are common to all the examples and help getting started in the Ethereum test network called Ropsten. After running the examples you can reuse the same address to deploy your own contracts.
Creating an address and get some Ether in it (MetaMask)
Export and note your Ethereum private key from MetaMask pressing the three lines menu button, Details, and finally Export private key (you will be prompted for the password you created when you installed MetaMask).
Registering to an RPC node (Infura)
In order to interact with the Ethereum blockchain, an RPC node exposing API is needed. In this example, we’ll be using https://infura.io that offer this service for free. Register to their website and note your API key (e.g. 607c53ff4845226fa6c4b060fd1db12d).
Both the examples have a config.py file to be edited with the information from the steps above and some example-specific variables.
Running the examples
From Zerynth Studio, after uplinked the project to your microcontroller, open the serial monitor to check the progress of the execution.
In the Simple Transaction example, the final output should be the transaction hash and a link pointing to the relative Etherscan page, a simple external tool to monitor the status of your transaction and check if it gets mined. It also shows other useful information like the waiting time and the used gas.
In the Dice Game example, the output should be a link to your Etherscan transaction. After the transaction completes and gets mined, the smart contract will decide if you won or not. You can check your account balance or the internal transaction from Etherscan to see if you won. Reset your device to run again the example and try again another bet if you feel lucky.
We hope that you enjoyed the whole tutorial, even if you didn’t win in the Dice Game. Download Zerynth Studio, and start combining IoT and Blockchain with our Python tools.