You forgot your Kali Linux password, and you cannot log in anymore? No worries, in this blog post, we'll walk you through a step-by-step guide on how to reset your forgotten password on Kali Linux, so you can regain access to your system in no time. So, grab a cup of coffee and let's get started!

3 steps

• Step 1 - Reboot into GRUB boot menu
• Step 2 - Edit the booting instructions
• Step 3 - Change password

Step 1 - 🎬 Reboot into GRUB boot menu

When the below screen is displayed, press "e" key to edit this boot menu.

Step 2 - ✏️ Edit the booting instructions

Now that we can edit the boot menu, let's make some changes. In a few words, this menu tells the machine what to boot and how to boot it. We will make some modifications to boot with bash command.

Find the line starting with "linux", and:

1. Replace "ro" by "rw" (i.e. read-only mode is replaced by read-write mode)
2. Add the end of the line, add: "init=/bin/bash"

So, you should start with:

And end with:

Once changes done, press: "CTRL+X"

It should reboot with bash command.

Step 3 - 🔐 Change password

You should see the following screen after booting:

Now, type: "passwd"

(If you need to change password for a specific user, you can add the username after passwd, like: "passwd username").

The prompt will ask you to define the new password, and to confirm it.

Once done, you can reboot, and you are all set.

Congrats 🥳 .

In this short tutorial, we will see how to add an external USB drive to Proxmox Virtual Environment 7.3-3 .

We will assume the Proxmox environment is installed and well configured.

Here are the steps we will go through:

1. 🔌 Plug the USB disk in the machine
2. 🗻 Create a mount point
3. 🧽 Format the USB disk
4. 🛠️ Configure fstab
5. ✨ Reboot

You will see how easy it is, let's go!

🔌 Step 1 - Plug the USB disk in the machine

I think we can skip this one :-).

🗻 Step 2 - Create a mount point

Now that our USB disk has been plugged, we need to create a mount point in our Proxmox VE, using the Shell.

Let's create the following directory in the /media directory:

cd /media
mkdir -p henri/EXT_DISK_2T

In my case, I'm using a 2To USB disk, but you are free to use the one you want.

• "mkdir -p" is used to create multiple subdirectories using "mkdir". It makes sure that "mkdir" adds any missing parent directories in the process.
• Replace the name of the directory as you want, of course 😃.

🧽 Step 3 - Format the USB disk

Now that we created a mounting point, we need to format our disk properly. In this case, we will use the "exfat" type. You are free to use the type you want.

Before formatting, make sure you identified the right disk (!). To check this, let's run the command:

fdisk -l

You should see something similar to:

root@pve:/media/henri# fdisk -l
Disk /dev/sda: 465.76 GiB, 500107862016 bytes, 976773168 sectors
Disk model: Samsung SSD 870 
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: gpt
Disk identifier: 598755F6-ED7D-429A-9E22-7585CD559E5F

Device       Start       End   Sectors   Size Type
/dev/sda1       34      2047      2014  1007K BIOS boot
/dev/sda2     2048   1050623   1048576   512M EFI System
/dev/sda3  1050624 976773134 975722511 465.3G Linux LVM


Disk /dev/mapper/pve-swap: 7.67 GiB, 8237613056 bytes, 16089088 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes


Disk /dev/mapper/pve-root: 96 GiB, 103079215104 bytes, 201326592 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes


Disk /dev/mapper/pve-vm--101--disk--0: 32 GiB, 34359738368 bytes, 67108864 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 65536 bytes / 65536 bytes
Disklabel type: dos
Disk identifier: 0xdc483fa1

Device                                 Boot    Start      End  Sectors  Size Id Type
/dev/mapper/pve-vm--101--disk--0-part1 *        2048 65107967 65105920   31G 83 Linux
/dev/mapper/pve-vm--101--disk--0-part2      65110014 67106815  1996802  975M  5 Extended
/dev/mapper/pve-vm--101--disk--0-part5      65110016 67106815  1996800  975M 82 Linux swap / Solar

Partition 2 does not start on physical sector boundary.


Disk /dev/mapper/pve-vm--100--disk--0: 100 GiB, 107374182400 bytes, 209715200 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 65536 bytes / 65536 bytes
Disklabel type: gpt
Disk identifier: 0ED5CE97-B11F-464C-A0E0-D44BA3FA3D5A

Device                                   Start       End   Sectors Size Type
/dev/mapper/pve-vm--100--disk--0-part1    2048      4095      2048   1M BIOS boot
/dev/mapper/pve-vm--100--disk--0-part2    4096   4198399   4194304   2G Linux filesystem
/dev/mapper/pve-vm--100--disk--0-part3 4198400 209713151 205514752  98G Linux filesystem


Disk /dev/sdb: 1.82 TiB, 2000398934016 bytes, 3907029168 sectors
Disk model: 2235            
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 4096 bytes
I/O size (minimum/optimal): 4096 bytes / 4096 bytes

As we can see here, we already have a disk sda with 3 partitions sda1, sda2, and sda3. Be careful not formatting this one, which is the root disk hosting Proxmox...

In our case, the plugged USB disk is called sdb (1.82 TiB).

To format sdb we will use the following command:

mkfs.exfat -n EXT_DISK_2T /dev/sdb

• exfat is the format we chose in this case.
• -n: the LABEL we give to our disk EXT_DISK_2T
• /dev/sdb: the device

To check if the disk was properly formatted, we can run

fsck.exfat /dev/sdb

We can see that everything was properly processed:

exfatfsck 1.3.0
Checking file system on /dev/sdb.
File system version           1.0
Sector size                 512 bytes
Cluster size                128 KB
Volume size                1863 GB
Used space                   61 MB
Available space            1863 GB
Totally 0 directories and 0 files.
File system checking finished. No errors found.

🛠️ Step 4 - Configure fstab

Now that we successfully formatted our disk, everything is ready. We need to add the information about our new disk in the fstab.

Doing this will ensure the "automount" of the disk when our drive reboot.

Check information using the following command

blkid

root@pve:~# blkid
/dev/sda2: UUID="C6B3-A88F" BLOCK_SIZE="512" TYPE="vfat" PARTUUID="fad7d0a1-ed35-412c-a2de-d9d8184141c1"
/dev/sda3: UUID="8kaOpu-dyIf-v6u2-t5tr-n55e-MO6Q-2BmQli" TYPE="LVM2_member" PARTUUID="9c8fe9ca-923b-4c11-ac5d-4f0e148c45a0"
/dev/mapper/pve-swap: UUID="6fd0c30d-94c2-4c04-ad3e-1ffe7ebf73c5" TYPE="swap"
/dev/mapper/pve-root: UUID="add66af1-bf90-4923-85ba-f11e95d53214" BLOCK_SIZE="4096" TYPE="ext4"
/dev/sda1: PARTUUID="0149cd14-1960-4a00-a08d-20accc1fff33"
/dev/mapper/pve-vm--101--disk--0: PTUUID="dc483fa1" PTTYPE="dos"
/dev/mapper/pve-vm--100--disk--0: PTUUID="0ed5ce97-b11f-464c-a0e0-d44ba3fa3d5a" PTTYPE="gpt"
/dev/sdb: LABEL="EXT_DISK_2T" UUID="CA16-A25B" BLOCK_SIZE="512" TYPE="exfat" PTTYPE="dos"

The last line displays our newly added disk information. Let's update the fstab file using this information.

nano /etc/fstab

You should see something close to this

/dev/pve/root / ext4 errors=remount-ro 0 1
UUID=C6B3-A88F /boot/efi vfat defaults 0 1
/dev/pve/swap none swap sw 0 0
proc /proc proc defaults 0 0

Let's add our new disk by editing the fstab file as following

/dev/pve/root / ext4 errors=remount-ro 0 1
UUID=C6B3-A88F /boot/efi vfat defaults 0 1
/dev/pve/swap none swap sw 0 0
proc /proc proc defaults 0 0
LABEL=EXT_DISK_2T /media/henri/EXT_DISK_2To exfat errors=remount-ro,defaults,users,noatime,nodiratime,umask=0 0 2

• LABEL=EXT_DISK_2T : our external disk label
• /media/henri/EXT_DISK_2To : the mount point
• exfat : filesystem type
• errors=remount-ro : mount the drive in 'read-only' if error occurs
• defaults : use default settings
• users : allows any user to mount/unmount the drive
• noatime : disables writing file access times to the drive every time you read a file
• nodiratime : disables the writing of file access times only for directories while other files still get access times written
• umask=0 : enables read/write access to all users
• 1 : used by the dump utility to decide when to make a backup
• 2 : sets the order for file system checks at boot time. The root device is set to 1, and other partitions are set to 2

To save and close the file, press CTRL+X and ENTER.

✨ Step 5 - Reboot

Now that everything has been properly set up, let's reboot the Proxmox host by typing

reboot

If everything was properly done, the machine should reboot properly.

To check if everything was properly done, we can run the following command

lsblk

We should see our disk displayed, as well as the mountpoint

NAME                         MAJ:MIN RM   SIZE RO TYPE MOUNTPOINT
sda                            8:0    0 465.8G  0 disk 
├─sda1                         8:1    0  1007K  0 part 
├─sda2                         8:2    0   512M  0 part /boot/efi
└─sda3                         8:3    0 465.3G  0 part 
  ├─pve-swap                 253:0    0   7.7G  0 lvm  [SWAP]
  ├─pve-root                 253:1    0    96G  0 lvm  /
  ├─pve-data_tmeta           253:2    0   3.5G  0 lvm  
  │ └─pve-data-tpool         253:4    0 338.7G  0 lvm  
  │   ├─pve-data             253:5    0 338.7G  1 lvm  
  │   ├─pve-vm--101--disk--0 253:6    0    32G  0 lvm  
  │   └─pve-vm--100--disk--0 253:7    0   100G  0 lvm  
  └─pve-data_tdata           253:3    0 338.7G  0 lvm  
    └─pve-data-tpool         253:4    0 338.7G  0 lvm  
      ├─pve-data             253:5    0 338.7G  1 lvm  
      ├─pve-vm--101--disk--0 253:6    0    32G  0 lvm  
      └─pve-vm--100--disk--0 253:7    0   100G  0 lvm  
sdb                            8:16   0   1.8T  0 disk /media/henri/EXT_DISK_2To

Congrats! You successfully mounted an external USB disk to your Proxmox host!

2. Search for the local storage displaying ISO images in its submenu, and select the ISO images menu. This list beside will display all the ISO images you already uploaded to the server.

3. Click the Upload button

4. Select the ISO image you would like to upload.

You are done :-).

Cheers!

In this tutorial, we will learn how to store data from a sensor to the Ethereum Blockchain. At the end, we will be able to see the data stored in Ethereum, via Etherscan, as follow.

Tutorial' Steps

1. Setup
2. Fetch Data from Sensor
3. Create & Migrate Smart Contract

Let's go!

Step 1 - ️⚙️ Setup

NodeJS

Install the latest version of NodeJS & NPM (package manager). In this tutorial, I'm using the v14.16.0. You can download the LTS version here.

Truffle

"Truffle is the most popular development framework for Ethereum with a mission to make your life a whole lot easier".

Truffle can be installed via npm, by typing the following command in your terminal. More info here.

npm install truffle -g

Ganache

"Quickly fire up a personal Ethereum blockchain which you can use to run tests, execute commands, and inspect state while controlling how the chain operates."

Ganache helps us launching a local blockchain in order to test, and develop. When you downloaded it, run it. You should have a window displaying 10 accounts with 100 $ETH each (hum, fake ETH sorry... 😉).

Web3

"web3.js is a collection of libraries that allow you to interact with a local or remote ethereum node using HTTP, IPC or WebSocket."

More info here.

npm install web3

HDWalletProvider

This library will help us signing transaction for addresses derived from a 12 or 24 word mnemonic.

More info here.

npm install @truffle/hdwallet-provider

Axios

"Promise based HTTP client for the browser and node.js".

More info here. In short, Axios is a NodeJs library allowing us to fetch the data from our sensor.

npm install axios

Now, we are all set, let's start 😀 .

Step 2 - 🪝 Fetch Data From Sensor

In this tutorial, we will use 2 components a DHT11 sensor, and an ESP8266 module. We will assume you already flashed the ESP8266, with Tasmota. If you don't know how to proceed, please have a look to one of my tutorial about that part.

DHT11

• Amazon

ESP8266

• Amazon

Data are accessible via an HTTP request, as explained in the Tasmota documentation (here, see 'with Web Requests' section).

In this case, we will use the following URL:

http://192.168.1.62/cm?cmnd=Status%2010

• 192...: my sensor's ip address
• cm?...: the command getting the status data

If you follow that link in a web browser, you should see an object displaying your sensor's data:

Ok, now we need to fetch these data. That's why we previously installed the Axios library.

In our main directory, let's run the following command in our terminal, to initiate our project:

npm init

A package.json file should have appeared in our directory.

Now, let's create our script file, index.js and open it. In your terminal, run the following command

touch index.js

In this new file, type the code below:

const axios = require('axios');

const url = 'http://192.168.1.62/cm?cmnd=Status%2010';

const getData = async() => {
    const response = await axios.get(url);
    let result;
    if(response.status == 200){
        const data = {
            server: response.headers.server,
            timestamp: response.data.StatusSNS.Time,
            temperature: parseInt(response.data.StatusSNS.DHT11.Temperature),
            humidity: parseInt(response.data.StatusSNS.DHT11.Humidity),
            dewpoint: parseInt(response.data.StatusSNS.DHT11.DewPoint),
        };
        result = JSON.stringify(data);
    }
    console.log(result);
    return result;
}

getData();

Comments

• Import axios library in our file
• Store the URL including the Tasmota command in a variable called URL. This address should be different on your side. When you flash Tasmota on the ESP8266 module, it assign a random IP address to the compoment.
• Define a function getData to fetch the data with Axios.
• In summary: if we have an answer from the module, then we collect and allocate the different data in an object called data (server, timestamp, humidity, etc.). Finally, we convert this object into a string (easier for the Smart Contract in Solidity part), and return the data.

Now, we have our data. Let's move on the Blockchain part.

Step 3 - 🔥 Smart Contract

In the step 1, we installed the Truffle framework. This will help us structure our Smart Contract part.

In your terminal, run the following command

truffle init

Now, you should have the following structure in your main directory:

├── contracts
│   └── Migrations.sol
├── index.js
├── migrations
│   └── 1_initial_migration.js
├── node_modules
   └── ...
│── package-lock.json
├── package.json
├── test
└── truffle-config.js

In the contracts folder, create a new folder called MyContract.sol . This file will hold our Smart Contract in Solidity.

touch contracts/MyContract.sol

Here is our Smart Contract code. This tutorial is not about how to write Smart Contract in Solidity. So, we won't go in details of this contract.

pragma solidity >=0.4.16 <0.9.0;

contract MyContract {
    string data;

    event MyData (
        address indexed from,
        string data
    );

    function set(string memory x) public {
        data = x;
        emit MyData(msg.sender, data);
    }

    function get() public view returns(string memory) {
        return data;
    }
}

In a few words:

• We define 2 functions: set and get.
• As you probably guessed already, the set function will 'store' the data we send to the Smart Contract, while the get function will return the value we stored.
• As you can see, we also add an event emitted in the set function.

Now, we need to compile and migrate that MyContract.sol .

In the Migrate directory, create a new file called 2_contract_deploy.js, and write the following code inside:

const MyContract = artifacts.require('MyContract');

module.exports = function(deployer){
    deployer.deploy(MyContract);
}

In our terminal, run the following command

truffle migrate --reset

You should see the following answer in your Terminal

Compiling your contracts...
===========================
> Compiling ./contracts/MyContract.sol
> Artifacts written to /Users/henririon/Documents/Tutorials/From Sensor To Blockchain/build/contracts
> Compiled successfully using:
   - solc: 0.5.16+commit.9c3226ce.Emscripten.clang



Starting migrations...
======================
> Network name:    'ganache'
> Network id:      5777
> Block gas limit: 6721975 (0x6691b7)


1_initial_migration.js
======================

   Replacing 'Migrations'
   ----------------------
   > transaction hash:    0x984378f75dc8f252a4d51d1ad85ee72433aadb0a50be092130c0e2b516d315ed
   > Blocks: 0            Seconds: 0
   > contract address:    0xF07f86C3b0445DA2f0157C60B617F394b08ddc77
   > block number:        23
   > block timestamp:     1629645715
   > account:             0x95Cba0aAA08704fDFc52312C2F130dd6312F6766
   > balance:             99.94825178
   > gas used:            191943 (0x2edc7)
   > gas price:           20 gwei
   > value sent:          0 ETH
   > total cost:          0.00383886 ETH


   > Saving migration to chain.
   > Saving artifacts
   -------------------------------------
   > Total cost:          0.00383886 ETH


2_contract_deploy.js
====================

   Deploying 'MyContract'
   ----------------------
   > transaction hash:    0x8fb6a0a2f9187d5928b7e00290c04444e4400b5f5c0cf99182b0ed3708948596
   > Blocks: 0            Seconds: 0
   > contract address:    0x4Ad94cE4c77c7Efeb2B6742125E6300E41c09Db4
   > block number:        25
   > block timestamp:     1629645715
   > account:             0x95Cba0aAA08704fDFc52312C2F130dd6312F6766
   > balance:             99.94205754
   > gas used:            267374 (0x4146e)
   > gas price:           20 gwei
   > value sent:          0 ETH
   > total cost:          0.00534748 ETH


   > Saving migration to chain.
   > Saving artifacts
   -------------------------------------
   > Total cost:          0.00534748 ETH


Summary
=======
> Total deployments:   2
> Final cost:          0.00918634 ETH

This answer shows our deployed contract to our local blockchain. If we had deployed that contract in the Mainnet, it would have cost some Gas for real. Here, these are fake Ether.

In your Ganache window, you should see the first account with a balance close to 99 ETH since we 'pay' a GasPrice to deploy.

So far, we collected our data, and we now deployed our Smart Contract in our local Blockchain.

Let's return now in our index.js file.

Step 4 - 🤙🏻 Interact with our Smart Contract

In our index.js , we will write the script's part allowing us to interact with our Smart Contract. In other words, we will send some data to the contract, and then we will check the data.

Here is the code:

const HDWalletProvider = require('@truffle/hdwallet-provider');
const axios = require('axios');
const Web3 = require('web3');
const MyContract = require('./build/contracts/MyContract.json');

const ganache = 'http://127.0.0.1:7545';

const address = '0x904202186FF74eF4E78D12bf161796F18BAE3081';
const privateKey = '633962326604757f2676241bf34b55eababe2c6314a7f456fd911f3fb1abd94e';

const url = 'http://192.168.1.62/cm?cmnd=Status%2010';

const getData = async() => {
    const response = await axios.get(url);
    let result;
    if(response.status == 200){
        const data = {
            server: response.headers.server,
            timestamp: response.data.StatusSNS.Time,
            temperature: parseInt(response.data.StatusSNS.DHT11.Temperature),
            humidity: parseInt(response.data.StatusSNS.DHT11.Humidity),
            dewpoint: parseInt(response.data.StatusSNS.DHT11.DewPoint),
        };
        result = JSON.stringify(data);
    }
    console.log(result);
    return result;
}

const main = async() => {
    const provider = new HDWalletProvider(
        privateKey,
        ganache
    );

    const web3 = new Web3(provider);
    
    const id = await web3.eth.net.getId();
    const deployedNetwork = MyContract.networks[id];

    let contract = new web3.eth.Contract(
        MyContract.abi,
        deployedNetwork.address
    );

    const accounts = await web3.eth.getAccounts();

    let result = await getData();
    console.log(result);

    try {
        const receipt = await contract.methods.set(result).send({
            from: address,
            gas: 3000000,
        });
    
        console.log(receipt);
    
        const x = await contract.methods.get().call({
            from: address, 
            gas: 3000000,
        });
        console.log(x);


    } catch (error) {

        console.log(error)
    
    }
}

main();

Comments:

1. We import the required libraries: @truffle/hdwallet-provider (library to sign transaction), web3 (library to interact with Smart Contracts), our MyContract (our Smart Contract).
2. We store the Ganache host in a variable. You can see this address in your Ganache window. In my case, I have http://127.0.0.1:7545 .
3. We store an Ethereum address to a const address (I toke the first address displayed in Ganache)
4. We store the Private Key (available in Ganache by clicking the key on the right of the required account)
5. We declare our custom provider using the HDWallerProvider library, including the privateKey constant, and the Ganache host address as parameters
6. We instantiate Web3 using our custom provider,
7. We instantiate our Contract using the web3 library.
8. In a the try/catch section, we send a Transaction to the method 'set' including our data stored in the const result as parameter. To use the send method, we also need to include 2 parameters 'from' (the source address), and the gas limit. More info here.
9. Then we call the get method in order to see the data we stored.

As a result, in the Terminal, you should see:

The receipt of the Send Transaction part

{
  transactionHash: '0x787708a586df25dc1e6c39305995db56be1d0c13fa14ac8cd4de3393b9984051',
  transactionIndex: 0,
  blockHash: '0x0f1e2333a29692deea4824f0a5ea6e7c4c6d83fc7a3ab5bcff19b8e700110b5c',
  blockNumber: 7,
  from: '0x904202186ff74ef4e78d12bf161796f18bae3081',
  to: '0xca9c9833e58275dd66b47dfc8a560700d9abd474',
  gasUsed: 45668,
  cumulativeGasUsed: 45668,
  contractAddress: null,
  status: true,
  logsBloom: '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000004000000000000000000002000000000000800000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000',
  events: {
    MyData: {
      logIndex: 0,
      transactionIndex: 0,
      transactionHash: '0x787708a586df25dc1e6c39305995db56be1d0c13fa14ac8cd4de3393b9984051',
      blockHash: '0x0f1e2333a29692deea4824f0a5ea6e7c4c6d83fc7a3ab5bcff19b8e700110b5c',
      blockNumber: 7,
      address: '0xca9c9833e58275Dd66b47Dfc8A560700D9ABd474',
      type: 'mined',
      id: 'log_ddf3b684',
      returnValues: [Result],
      event: 'MyData',
      signature: '0xa8073d849fb4a3e09df83ab9787898c62652336cd0d79a6e402438f64af7aeac',
      raw: [Object]
    }
  }
}

and from the get method, you should see our sensor's data:

{"server":"Tasmota/9.5.0 (ESP8266EX)","timestamp":"2021-08-22T16:51:23","temperature":24,"humidity":63,"dewpoint":17}

Hurraaaa! It works 🎉🥳 ! Congrats, you successfully collect the data from the sensor, and store it in our local blockchain!

Hold on, this is not the end! Now, let's store this data on the Public Testnet Ropsten from Ethereum.

Step 5 - Store the Data to Ropsten (Public Testnet Ethereum)

What is Ropsten?

Here is a very good definition:

Ropsten Ethereum, also known as “Ethereum Testnet”, are as the name implies, a testing network that runs the same protocol as Ethereum does and is used to testing purposes before deploying on the main network (Mainnet).

Ethereum has several networks. Your Valuable ETHs are in the Main Net. The rETHs are on the Ropsten one.

Ropsten ETHs are used for testing purposes. When developers are building dApps, or experimenting on the network, to avoid losing money paying real ETH for transaction fees and smart contract deployments, it’s better to use the Ropsten Network.

More info in this very good article.

Step 5.1. - Infura

To deploy our Smart Contract to Ropsten, we need an access to an Ethereum node. Either, you are lucky, and you have your own node, or, like me, you don't, and you need another solution 😃. This solution is called Infura.

The World’s Most Powerful Blockchain Development Suite

Our suite of high availability APIs and Developer Tools provide quick, reliable access to the Ethereum and IPFS networks so you can focus on building and scaling next generation software.

Infura allows us to interact with Ethereum networks (Mainnet & Testnets) by using an API. Hopefully this service is FREE.

Create your account, and let's move on.

Once signed up, let's create a project.

Once created, you can copy the Testnet Ropsten endpoint.

Step 5.2. - Setup Metamask

If it's not the case already, install the Metamask extension to your chrome, by clicking here. Follow the steps.

Once installed, and set up, click on the top right icon, create a new Account, and call it Test.

Copy the Account address, right under the Test title. Now, we need to provide 'fake' Ether to this account, in order to 'pay' our deployment within the Testnet Network.

🚰 Go to https://faucet.ropsten.be/, paste your account address, and click on 'Send me test Ether'. After a couple of seconds/minutes, you will see the test Ether arrives on your Test account in Metamask.

⚠️ Warning⚠️  --> Avoid clicking several times on the Send button, to avoid being blacklisted!

Once you received your 5 ETH, we can move on.

Now let's edit our index.js script to deploy on the Testnet.

Here is the code, comments are following:

const HDWalletProvider = require('@truffle/hdwallet-provider');
const axios = require('axios');
const Web3 = require('web3');
const MyContract = require('./build/contracts/MyContract.json');

const ropsten = 'https://ropsten.infura.io/v3/e944752a46184aaa8800e8c138886d1a';

const address = 'Your Metamask Account Address';
const privateKey = 'Your Metamask Private Key Account';

const url = 'http://192.168.1.62/cm?cmnd=Status%2010';

const getData = async() => {
    const response = await axios.get(url);
    let result;
    if(response.status == 200){
        const data = {
            server: response.headers.server,
            timestamp: response.data.StatusSNS.Time,
            temperature: parseInt(response.data.StatusSNS.DHT11.Temperature),
            humidity: parseInt(response.data.StatusSNS.DHT11.Humidity),
            dewpoint: parseInt(response.data.StatusSNS.DHT11.DewPoint),
        };
        result = JSON.stringify(data);
    }
    console.log(result);
    return result;
}

const main = async() => {

    const provider = new HDWalletProvider(
        privateKey,
        ropsten
    );

    const web3 = new Web3(provider);

    let contract = new web3.eth.Contract(
        MyContract.abi,
    );

    contract = await contract
        .deploy({data: MyContract.bytecode})
        .send({from: address});

    let result = await getData();
    console.log(result);

    try {
        const receipt = await contract.methods.set(result).send({
            from: address,
            gas: 3000000,
        });
    
        console.log(receipt);
    
        const x = await contract.methods.get().call({
            from: address, 
            gas: 3000000,
        });
        console.log(x);


    } catch (error) {

        console.log(error)
    
    }
}

main();

Comments

• We store the API address provided by Infura in the Ropsten constant
• We store the Metamask Account address in the Address constant
• We store the Metamask Account Private Key

Where to find the Metamask Account Private Key?

• We define our custom provider by using the Ropsten API address.
• After, we instantiate again web3, and our Smart Contract, but we don't use the deployedNetwork as performed previously, which is our local blockchain.

Now run the following code in your terminal:

node index.js

It will be a bit slower than before since it's on the public testnet now.

You should see the receipt, and the get data result.

{
  blockHash: '0xc078972c8c6a90b60d2ce677cae3f277380b0eb74d6bdbdabe78bc4131cc2586',
  blockNumber: 10888390,
  contractAddress: null,
  cumulativeGasUsed: 611127,
  effectiveGasPrice: '0x59682f0e',
  from: '0xdbd78940117b014c4738b850d5e1eb92adfe1b13',
  gasUsed: 138768,
  logsBloom: '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000080000000000001000000000000000000000000000000000000000000000000000000000080000001002000000000000000000000000000000000000000000010000000000000000020000000000000000000000000',
  status: true,
  to: '0x2472fe4510696302e31382229400822ec6b0fced',
  transactionHash: '0x21acdc35d63c9e078bd86fe75f92b4f8b1dad2f758de4d872f282e623328ba34',
  transactionIndex: 3,
  type: '0x0',
  events: {
    MyData: {
      address: '0x2472FE4510696302e31382229400822ec6b0FceD',
      blockHash: '0xc078972c8c6a90b60d2ce677cae3f277380b0eb74d6bdbdabe78bc4131cc2586',
      blockNumber: 10888390,
      logIndex: 9,
      removed: false,
      transactionHash: '0x21acdc35d63c9e078bd86fe75f92b4f8b1dad2f758de4d872f282e623328ba34',
      transactionIndex: 3,
      id: 'log_a3f66bda',
      returnValues: [Result],
      event: 'MyData',
      signature: '0xa8073d849fb4a3e09df83ab9787898c62652336cd0d79a6e402438f64af7aeac',
      raw: [Object]
    }
  }
}
{"server":"Tasmota/9.5.0 (ESP8266EX)","timestamp":"2021-08-22T17:21:28","temperature":24,"humidity":63,"dewpoint":17}

Now copy the 'to' hash code (0x2472fe4510696302e31382229400822ec6b0fced), which is the contract address on the blockchain, and paste it to https://ropsten.etherscan.io/  (we have to use ropsten etherscan since we are on the Test net).

On the printscreen:

1. Corresponds to the contract deployment
2. Corresponds to the set data operation

If you click on the Txn Hash of the Set Method, you should see our Sensor Data !

Congrats!  We are all done now.

I hope you enjoyed this tutorial, feel free to reach out!  

Tired using plenty of remote controllers at home for TV, AC, Leds, Internet Box...? With a simple DIY Infrared Bridge, control your IR devices through Home Assistant.

🚨 Assumptions

Before we start, I'm assuming in this tutorial that:

• Home Assistant is installed, configured, and running,
• MQTT Broker is installed, configured, and running,
• You know the Protocol, Code, and Length to transmit via IR. We will use NEC, 16712445, 32 in here.

Check my other articles to see how to capture codes, protocol, and code's length.

🛍️ Required Materials

Links to Amazon are used for illustration, and not promotion. Of course, you can find the required materials elsewhere such as Aliexpress.

• ESP8266

• IR transmitter

• 3 jumpers female-female + 1 USB Cable

⚡ Flashing ESP8266 with Tasmota

Flashing the ESP8266 with Tasmota firmware is not the purpose of this tutorial. In case you don't know how to proceed, please have a look to my other tutorial.

🔌 Plugging Components Together

Now, we installed Tasmota firmware on our ESP8266, we can plug components together. Here are the required connections, from ESP8266 to IR Transmitter:

• GND -> GND
• 3V3 -> VCC
• D3 -> SIG

🪛 Tasmota Configuration

• Go to the allocated IP address of our wonderful Tasmota
• In this case, we have 192.168.1.62
• Go to : Configuration > Configure Module, and select Generic module type, and allocate IRSend to the D3 GPIO0

In terms of our hardwares configuration, we are now good. Let's move on with Home Assistant.

🏠 Home Assistant Integration

If you didn't already add  Tasmota entities to Home Assistant yet, go to Configuration > Integrations > Add Integration > Tasmota.

You should now be able to see Tasmota entities available on your network.

🧪 Testing first!

Before final integration, let's test the communication between MQTT, and our Tasmota device.

On a new tab of your favorite browser, open the Tasmota panel (192.168.1.62), and go to Console.

Open a new tab with Home Assistant, and go to Configuration > Integrations, and click on the MQTT Configure button.

In the "Publish a Packet" part, we will add the topic (i.e. the name of our Tasmota), and the Payload (the code we want to execute).

🔍 Where to find the MQTT Topic?

On the Tasmota tab, go to the Information menu, and find the "MQTT Full Topic". In our case, we have:

cmnd/tasmota_E30D62/

Add this topic name to our Home Assistant MQTT Configure panel, with IRsend at the end.

cmnd/tasmota_E30D62/irsend

🔎 Where to find the Payload?

As previously explained, in this case, we assume having already the code, and protocol.

Payload

{"Protocol":"NEC","Bits":32,"Data":16753245}

And now click publish.

You should see the Tasmota's console displaying the below message:

MQT: stat/tasmota_E30D62/RESULT = {"IRSend":"Done"}

Integration

Open your configuration.yaml file and add the following lines:

switch:
  - platform: mqtt
    name: "TEST ESP8266 LED LIGHT" #the entity name
    command_topic: "cmnd/tasmota_E30D62/IRsend"
    payload_on: '{"Protocol":"NEC","Bits":32,"Data":16712445}'
    payload_off: '{"Protocol":"NEC","Bits":32,"Data":16712445}'

Save and close the configuration.yaml file. For the tutorial, I'm limiting the codes to toggle ON/OFF. Of course, you can add all the required codes.

Check the configuration within Home Assistant. Go to Configurations > Server Controls > Configuration Validation > Check Configuration.

You must have the "Configuration Valid!" message.

Once the configuration valid message appears, you can restart Home Assistant server.

💡 New Entity Usage

Now, to see our brand new DIY IR Bridge in action, we can create a new view, and click the add card button.
Select the Button card type.
Find the Entity we just created, and save.

Now, you have an IR Bridge working.

I hope you enjoyed this tutorial.

Do not hesitate to ask questions, or give improvements. I'm always open to improve and share 🤙.

In this tutorial, I will show you how I flashed an ESP8266 with Tasmota firmware.

Step 1: 📥 Download ESP Flasher & Tasmota

• ESP Flasher: github repo, and download the appropriate version of ESP Flasher (no need to install)
• Tasmota firmware: tasmota.bin.gz

Step 2: 🔌 Plug ESP8266 to your computer in Boot Mode

Plug the ESP8266's USB to your computer, while pressing the Flash button simultaneously.

Step 3: ⚡Flashing

• Reload the Serial Port until you see your USB plug appearing
• Browse the firmware Tasmota we downloaded locally in Step 1
• Launch ESP-Flasher

This process could take up to 30 sec.

Once done, unplug, and replug the ESP8266 to the computer or any other source of power.

Step 4: 📡 WiFi Connection

• Once relaunched, you should see a "Tasmota_XXX" WiFi appearing in your networks.
• Connect your computer to the Tasmota WiFi
• Connect your WiFi (SSID + Password)
• Click Ok
• Let the component restart

Step 5: 🔥 Tasmota Configuration

Configure MQTT Broker accordingly (host + port + login + password)

This short blog post aims at helping those who are struggling (like me ) to setup properly Ghost and emails (using Mailgun).

I didn't find a lot of examples online, thus, I hope this methodology will help some people.

Mailgun

Mailgun is a Powerful APIs that enable you to send, receive and track email effortlessly

First of all, you have to know that I could setup Ghost with the free version of Mailgun. Actually, it's only working as a sandbox, and cannot be used to send transaction emails...

Here is the error I get when I'm using the sandbox domain.

Failed to send email. Reason: Data command failed - 421 Domain sandboxf3d5782960c94fb0ab88532620e41c77.mailgun.org is not allowed to send: Sandbox subdomains are for test purposes only. Please add your own domain or add the address to authorized recipients in Account Settings..

Thus, once you created your account in Mailgun (including you credit card 🤑), you will be able to create a new domain (if you keep the free version, you won't see the Add Domain Button).

Now go to:

1. Sending menu
2. Domains submenu
3. Add New Domain button

Then,

1. Edit your Domain name as in the illustration I'm using myawesome.website
2. Select the appropriate domain region
3. Add Domain

The next page will show you the DNS records to add to your host.

Depending on your Host solution, you could have to wait up to 24 hours to ensure 100% propagation of the new & updated DNS records.

To check if it's properly deployed, you can use the Verify DNS settings in the Mailgun dashboard.

Once these are good, you will be redirected to method (API vs SMTP). (don't have printscreen for that part). In our case, we will chose the SMTP methodology.

Mailgun will generate credentials we will need to add to our Ghost docker-compose.

Docker-compose Update

When using Docker image, Ghost is not using a config file (config.production.json), but mails settings must be referenced using ENV variables.

(Source: https://ghost.org/docs/config/#running-ghost-with-config-env-variables).

Here is my updated docker-compose.yml file:

version: '3'
services:
  ghost:
    image: ghost:4-alpine
    ports:
      - ****:2368
    environment:
      url: https://myawesome.website
      mail__transport: SMTP
      mail__options__service: Mailgun
      mail__options__host: smtp.eu.mailgun.org
      mail__options__port: 587
      mail__options__auth__user: postmaster@myawesome.website
      mail__options__auth__pass: ************
    volumes:
      - ./data:/var/lib/ghost/content
    restart: unless-stopped
    [...]

Save and you should be good.

Now let's restart our docker-compose.yml:

docker-compose up

And try create a new users.

You should now receive the subscription confirmation email.

Well done, you have now your emails working :-).

Hold-on, if you don't have a Raspberry Pi, yet, I can recommend these:

Step 1: 🍓 Get Raspberry Pi Imager

The Raspberry Pi Imager is used to install the OS on the microSD card. This program is compatible with MacOS, Windows, and Linux (click here to download).

Step 2: 🔌 Connect your microSD card to your computer

A microSD Card reader may be required depending on your computer setup.
I'm using this docker because I'm on a Mac:

Step 3: 🔥 Flash the Card with Ubuntu 21.04

Launch the Raspberry Pi Imager tool.

Depending on your Raspberry Pi, you'll need to select the appropriate operating system (64-bit vs 32-bit). I'm using the 64-bit version in this situation).

Now it's time to select the SD Card (be careful to select the correct one!).

Now that we're ready, we can click on the write button to flash the SD card.

Your microSD card will be flashed after a few minutes of writing and validating.

Step 4: 📡 Establish a WiFi connection

Eject the microSD card and reconnect it to your computer.

Now look for the "network-config" file in the microSD card directory (in the root folder).

Use your favorite IDE to open it. In this tutorial, I'll be utilizing Visual Studio Code.

The initial content of this file should look like this:

#[...] some comments
version: 2
ethernets:
  eth0:
    dhcp4: true
    optional: true
#wifis:
#  wlan0:
#    dhcp4: true
#    optional: true
#    access-points:
#      myhomewifi:
#        password: "S3kr1t"
#      myworkwifi:
#        password: "correct battery horse staple"
#      workssid:
#        auth:
#          key-management: eap
#          method: peap
#          identity: "me@example.com"
#          password: "passw0rd"
#          ca-certificate: /etc/my_ca.pem

As you can see, a section dedicated to wifis has already been written and commented on.

Edit the file as following:

version: 2
ethernets:
  eth0:
    dhcp4: true
    optional: true
wifis:
  wlan0:
  dhcp4: true
  optional: true
  access-points:
    your_wifi_name:
    password: "your_password"

Save the file and remove the microSD card from your computer correctly.

Step 5: 🏁 Turn on your Raspberry Pi.

Let's plug the microSD card back into the Raspberry Pi and turn it on now that we have a correctly flashed microSD card and a wifi connection.

Step 6: 🏠 Determine the IP address of your Raspberry Pi.

To connect to our Raspberry Pi, we must first determine its IP address.

There are several options here. The simplest method is to connect to your internet provider's box and look for our Raspberry Pi's new Ubuntu Server.

Here we have:

Step 7: 🛰️ SSH connection

What exactly is an SSH connection?

SSH is often used to log into a remote machine and perform commands, according to Wikipedia.

Open a Terminal command now.

ssh ubuntu@192.168.1.45

The default login is ubuntu, and @192.. is the IP address we found in the previous step.

The authenticity of host '192.168.1.45 (192.168.1.45)' can't be established.
ECDSA key fingerprint is SHA256:xxxxxx.
Are you sure you want to continue connecting (yes/no/[fingerprint])?

Type Yes.

Ubuntu is also the default password. After your first sign-in, you'll be prompted to change your password.

The connection will be immediately ended after the new password has been set. The ssh connection must be restarted with the new password you specified.

Step 8: 🍿 Enjoy

You're ready to go.

Comment ☝

Remember that we didn't give our Raspberry Pi a static IP address.

It means that the IP address will be updated dynamically (DHCP) over time.
Please see my next article if you require a static IP address (soon).

Post Scriptum

I recommend viewing this video if you want to learn more about the process.

👉 https://www.youtube.com/watch?v=dJTqd90bwsI

Metamask is a crypto wallet and a gateway to blockchain apps

More information on their website here.

How is Metamask included in our process?

When a transaction occurs, the frontend will send a signing request to Metamask. Then Metamask will ask the end user for signing or refusing the transaction.

If the user accepts the transaction, Metamask will sign it before sending it to the chosen blockchain. Metamask can connect to various networks such as the Mainnet, Public Testnet (Kovan, Ropsten, etc.), or even our local Blockchain.

Metamask will take care itself how to send the transaction to the required network, using Infura for instance when the chosen network is Mainnet or Public Testnet.

How to install Metamask?

Installing Metamask is quite easy.

1. Open Google Chrome or any other supported Browers (Chrome, Firefox, Brave, or Edge)
2. Add the Metamask extension, using this link
3. Follow the installation steps (don't forget to keep secret and in a safe place your Secret Backup Phrase)
4. Once installed you should be connected to the Ethereum Mainnet by default, on the Account 1

By clicking to the top, where it's written 'Réseau Principal Ethereum', you will see various available networks, as well as Custom RPC (mine is in French).

Now that we installed Metamask, we are ready to move on to our scripts.

Signing Transactions from an App using Metamask

In this section, we will re-use the contract we deployed on Ropsten network, in the section 8.

We will also use a simple Vue-App to perform the signed transaction. No worries, you don't need to know Vue to perform this part. We won't go in details on that front App part.

Setup Vue App

First, to use Vue we need a global addon to be installed with the Vue CLI. More info, here. Before launching this command, make sure we get the required permission, by switching to Super User mode. (E.g. using mac, we can type the following command, and enter your password).

sudo su

Then, we run:

npm install -g @vue/cli @vue/cli-service-global

Once installed, we can create our Vue App, by running the following command:

vue create client

In the menu, we select the Default Vue2 option:

Actually, we ask Vue to create a new App named client, using Vue2 here.

Now, you should have a directory tree similar to:

├── client ==> this is what we just created, using create vue client
│   ├── README.md
│   ├── babel.config.js
│   ├── node_modules
│   ├── package-lock.json
│   ├── package.json
│   ├── public
│   │   ├── favicon.ico
│   │   └── index.html
│   └── src
│       ├── App.vue
│       ├── assets
│       │   └── logo.png
│       ├── components
│       │   └── HelloWorld.vue
│       └── main.js
└── contract ==> where our contract stuff are stored (cf. part 8)

Let's clean a bit before going further.

In the client, directory, we find the 'HelloWorld.vue' components:

client/src/components/HelloWorld.vue

We delete everything, and we paste the following code:

<template>
  <div>
    <button>SendTransaction</button>
  </div>
</template>

<script>
export default {
  
}

In our terminal, in the client directory, we run

npm run serve

We have the following result:

> client@0.1.0 serve
> vue-cli-service serve

 INFO  Starting development server...
98% after emitting CopyPlugin

 DONE  Compiled successfully in 1828ms                                                                                             21:08:18


  App running at:
  - Local:   http://localhost:8082/ 
  - Network: http://192.168.1.6:8082/

  Note that the development build is not optimized.
  To create a production build, run npm run build.

Now, we go to the Network address 'http://192.168.1.6:8082/' and we make sure we have the following result:

We can see a SendTransaction button under the Vue logo.

Now let's code the interaction with Metamask.

We will split the next steps, in 2 parts: connect Metamask with our App, and then send a signed transaction. In our case, the transaction will consist in setting a new value using the set function.

In the next lines, I will do my best avoiding going in the Vue details, which is not the aim of the course.

Connect Metamask with our Vue App

First, we need to install some libraries:

• the Metamask 'detect-provider' libray and,
• the Web3 library

In our client directory, we run the following command in our terminal:

npm install @metamask/detect-provider web3

Now, we successfully installed the 2 libraries.

Here the updated 'HelloWorld.vue' code. Comments are following.

<template>
  <div>
    <div >{{ accounts[0] }}</div>
    <button>SendTransaction</button>
  </div>
</template>

<script>
import detectEthereumProvider from '@metamask/detect-provider'; 
import Web3 from 'web3';
import MyContract from '../../../contract/build/contracts/MyContract.json';

export default {
  data() {
    return {
      contractAbi: MyContract.abi,
      contractAddress: "0xe49082b47dA1f0E9FAEfc6463f0ef9aA114657A8",
      provider: '',
      web3: '',
      contract: '',
      accounts: '',
    }
  },

  async mounted() {
    await this.setup();
    this.provider = await detectEthereumProvider();
    if(this.provider){
      await this.getAccounts();
    }else{
      console.log('Please, Install Metamask!');
    }

  },

  methods: {
    async setup(){
      this.web3 = new Web3(window.ethereum);
      this.contract = new this.web3.eth.Contract(this.contractAbi, this.contractAddress);
    },

    async getAccounts(){
      this.accounts = await this.provider.request(
        {
          method: 'eth_requestAccounts',
        }
      )
    }
  }
}
</script>

For those who don't know Vue structure, .vue file are split into 2 main parts: the template, and the scripts. Here the template part is our HTML displaying the button, while the script part will include our Metamask logic.

Importations:

• We import the 2 libraries, we previously installed
• We import our contract ABI we build in the part 8 of the course.

In the data part, we define several variables we will be using:

• contractAbi: our contract generated ABI when we built and migrated our contract to the Ropsten network (cf. part 8).
• contractAddress: our contract address is stored here. this is the address we got when we deployed our contract on the Ropsten network (cf. part 8) (if you lost it, please restart the deployment part to the Ropsten network. You will get a new address).
• provider: our provider instance will be stored here
• web3: our web3 instance will be stored here
• contract: our contract instance will be stored here
• accounts: this variable will be used to store the connected account(s) address with Metamask. In our case, it will include only one address. But, if we would connect several accounts with Metamask, they would be store in the accounts array.

Now, let's generate the different required instances, and store them into our lovely variables. For this part, we need different methods:

setup function

• we instantiate our web3 using the window.ethereum provider (detect the Ethereum provider) provided by Metamask.
• we instantiate our contract using web3 instance, our contract ABI ('including functions, and variables of our Smart Contract'), and our contract address ('where our contract is stored in the Ropsten Network').

getAccounts

• Using the ethereum.request methods (more info from Metamask doc here), we ask Metamask to provide us with the list of connected accounts. This will be useful to sign the transaction later.

Now, in the 'mounted' part (part of the Vue lifecycle when the page is mounted. For those who are not familiar with Vue, keep in mind that this part will be ran when we load the page, more info here.), we need to run our methods to connect Metamask with our App, and get the available accounts:

• First we ran our setup method, to connect Metamask with our Vue App
• Then, we detect the provider provided by Metamask. If available we collect the connected accounts addresses, else, we ask our user to install Metamask.

Now, we successfully connected Metamask with our Vue App, and collected the available accounts.

When reloading your Vue App, we should see Metamask appearing, asking to select account(s) to connect with the App. We select an account (with some Faucet ETH), click Next, and Connect.

We can see that we are successfully connected:

In the template, we print our accounts[0] value, to see that we are well connected.

Please bear with me, we are close to our objective.

Send Signed Transaction to our Smart Contract

To keep things simple, by pressing the button 'SendTransaction' we created, we will change the uint in our contract from 10 to let's say 100.

Let's code it.

Now that we are connected, and we have the account address, we can send a signed transaction to our contract by simply adding the following function to our script part. Here are the updates to perform in our code. Comments are following.

In the data part, we add a new variable called message, with the value we want to set in our Smart Contract, 100.

data() {
    return {
      contractAbi: MyContract.abi,
      contractAddress: "0xe49082b47dA1f0E9FAEfc6463f0ef9aA114657A8",
      provider: '',
      web3: '',
      contract: '',
      accounts: '',
      message: 100,
    }
  },

In the methods, we add a new method called setNewValue. Comments are following.

async setNewValue(){
      const receipt = await this.contract.methods.set(this.message.toString()).send({
        from: this.accounts[0],
      });
      console.log(receipt);
    }

• We use our contract instance, selecting the 'set' method, and we send the new value stored in the message variable, that we convert into a String.
• As parameter, we add the source accounts
• Finally, we console log the receipt of the transaction.

Now we need to link this method with our button, by updating the code as following:

<template>
  <div>
    <div >{{ accounts[0] }}</div>
    <button @click="setNewValue">SendTransaction</button>
  </div>
</template>

Now, in our App, we can click on the SendTransaction button. A Metamask window opens showing us our transaction details, and the gas fees we will pay to process the transaction.

Click on Confirm, and now let's wait a couple of seconds/minutes.

In our Chrome Console (right click in the page > inspect), we should see the Transaction receipt console.log when the transaction will be fully processed.

Let's check in Ropsten Etherscan, if we see our new value of 100 instead of 10.

• Go on https://ropsten.etherscan.io/
• Paste our Contract Address, in this case: 0xe49082b47dA1f0E9FAEfc6463f0ef9aA114657A8
• We can see our transaction on the top of the table
• Click on the transaction > click to see more > Decode Input Data

Hurra!  We successfully send a signed transaction using Metamask on the Ropsten Network.

Here is the HelloWorld.vue full and final code:

<template>
  <div>
    <div >{{ accounts[0] }}</div>
    <button @click="setNewValue">SendTransaction</button>
  </div>
</template>

<script>
import detectEthereumProvider from '@metamask/detect-provider'; 
import Web3 from 'web3';
import MyContract from '../../../contract/build/contracts/MyContract.json';

export default {
  data() {
    return {
      contractAbi: MyContract.abi,
      contractAddress: "0xe49082b47dA1f0E9FAEfc6463f0ef9aA114657A8",
      provider: '',
      web3: '',
      contract: '',
      accounts: '',
      message: 100,
    }
  },

  async mounted() {
    await this.setup();
    this.provider = await detectEthereumProvider();
    if(this.provider){
      await this.getAccounts();
    }else{
      console.log('Please, Install Metamask!');
    }

  },

  methods: {
    async setup(){
      this.web3 = new Web3(window.ethereum);
      this.contract = new this.web3.eth.Contract(this.contractAbi, this.contractAddress);
    },

    async getAccounts(){
      this.accounts = await this.provider.request(
        {
          method: 'eth_requestAccounts',
        }
      )
    },

    async setNewValue(){
      const receipt = await this.contract.methods.set(this.message.toString()).send({
        from: this.accounts[0],
      });
      console.log(receipt);
    }
  }
}
</script>

This is the end of the Web3 course. I hope you enjoyed it. Feel free to contact me if you had any questions, our improvement comments. Always keen to learn! Enjoy.

What is an Event?

An event emits data from a Smart Contract, when a transaction occurs.

This is useful when you need to monitor certain transactions and update your Web App, for instance.

It’s important to note that events are inheritable, and when generated they are not accessible from within contracts, not even the one which has created and emitted them.

If you need more details, have a look to the Solidity's events doc, here.

In the next sections we will go through 3 methods to read/listen to events.

Method 1 - Trigger Emit Event via a Transaction

In our contracts directory, we create a new file called MyContract3.sol . Here is the Smart Contract we will be using. Comments are following.

pragma solidity >=0.4.16 <0.9.0;

contract MyContract3 {
    event MyPayment (
        uint indexed date,
        address indexed from,
        address indexed to,
        uint amount
    );

    function payment(address to, uint amount) external {
        emit MyPayment(block.timestamp, msg.sender, to, amount);
    }
} 

In this solidity script, we are defining a function called Payment. This payment function is simulating a token transfer from an address to another, and will emit an Event when the function is called.

Thus, we define an event called MyPayment first. Each 'MyPayment' event will include 4 parameters:

1. Date: the date when the event occured (integer in Solidity)
2. From: the address which triggered the event
3. To: the target address of the payment
4. Amount: the amount of payment

What is indexed?

From Solidity Docs we can read:

"You can add the attribute indexed to up to three parameters which adds them to a special data structure known as “topics” instead of the data part of the log. [...] Topics allow you to search for events, for example when filtering a sequence of blocks for certain events."

Now, we can add the MyContract3.sol in our migration file 2_contract_deploy.js.

Here is the updated migration file:

const MyContract = artifacts.require('MyContract');
const MyContract2 = artifacts.require('MyContract2');
const MyContract3 = artifacts.require('MyContract3');

module.exports = function(deployer){
    deployer.deploy(MyContract);
    deployer.deploy(MyContract2);
    deployer.deploy(MyContract3);
}

Now, we can run the truffle migrate command to deploy our new MyContract3 to our local Blockchain.

truffle migrate --reset

We can see that our MyContract3.sol has been successfully migrated thanks to the output in terminal:

Deploying 'MyContract3'
   -----------------------
   > transaction hash:    0x1c167be3bb3c551e015101aa09b977b927b3a49befe411eef089252ec0f382e9
   > Blocks: 0            Seconds: 0
   > contract address:    0xded0Ab79D2ECe65a6dC08885608804e9c5e80b75
   > block number:        11
   > block timestamp:     1630570766
   > account:             0x65ca5ECfd87FaaFE35F63244133EFE9EDF2ABF55
   > balance:             98.97514394
   > gas used:            113737 (0x1bc49)
   > gas price:           20 gwei
   > value sent:          0 ETH
   > total cost:          0.00227474 ETH

Now, we can move on with our JS Script. Let's create a new index, called index3.js. Here is the code to paste in. Comments are following.

const Web3 = require('web3');
const MyContract3 = require('./build/contracts/MyContract3.json');

const init = async() => {
    const web3 = new Web3('http://127.0.0.1:7545');
    
    const id = await web3.eth.net.getId();
    const contract = new web3.eth.Contract(
        MyContract3.abi,
        MyContract3.networks[id].address
    );

    const accounts = await web3.eth.getAccounts();

    const receipt = await contract.methods.payment(accounts[0], '1000000000000000000').send({
        from: accounts[1],
    })
    console.log(receipt.events);
}

init();

First, we import our MyContract3. Then, create our web3, and contract instances.

Next, we get the accounts addresses from Ganache, and finally we call our new 'payment' method. As defined in our MyContract3.sol, we input the 2 required parameters (from and amount), and we send the transaction.

In our Terminal, we can see the following output, since we console.logged our receipt.events.

{
  MyPayment: {
    logIndex: 0,
    transactionIndex: 0,
    transactionHash: '0x3bc0cad631bee6e061f4b36a7a0c358831cde0edf7e05abae7dcc6a8a8ce76a0',
    blockHash: '0x083ece81a048cda77732aac4358e53b7dfffa1a7429fef03b0c4aff4258287d7',
    blockNumber: 13,
    address: '0xded0Ab79D2ECe65a6dC08885608804e9c5e80b75',
    type: 'mined',
    id: 'log_d92bbfed',
    returnValues: Result {
      '0': '1630571019',
      '1': '0x89d48bf3591db71C2EBd7Be9ea86Ce52442E474C',
      '2': '0x65ca5ECfd87FaaFE35F63244133EFE9EDF2ABF55',
      '3': '1000000000000000000',
      date: '1630571019',
      from: '0x89d48bf3591db71C2EBd7Be9ea86Ce52442E474C',
      to: '0x65ca5ECfd87FaaFE35F63244133EFE9EDF2ABF55',
      amount: '1000000000000000000'
    },
    event: 'MyPayment',
    signature: '0x3f149fb6578fdbf59cb6fffd764d2994d89b758e8dcadb7b14a8d37a05b90520',
    raw: {
      data: '0x0000000000000000000000000000000000000000000000000de0b6b3a7640000',
      topics: [Array]
    }
  }
}

• We can read the MyPayment event, the name of our event.
• Then a few lines below, we can read the date, the from & to addresses, and finally the amount.

It works! Great!

👎 Limitations

Thus, this option works great, but it has a limit. You need to be the sender of the transaction to read the event. Most of the time, it will not happen this way.

In most cases, we will need to read events triggered by other people.

Let’s move on to the next method.

Method 2 - getPastEvents

This method allows us to read all the events that occurred from a Smart Contract. We will still using our MyContract3.sol for this method. The only changes are made in our index3.js file.

(Before going, further, we will restart our Ganache Local Blockchain. Otherwise we will have noises in the events we will display. Don't forget to perform the migration using truffle).

const Web3 = require('web3');
const MyContract3 = require('./build/contracts/MyContract3.json');

const init = async() => {
    const web3 = new Web3('http://127.0.0.1:7545');
    
    const id = await web3.eth.net.getId();
    const contract = new web3.eth.Contract(
        MyContract3.abi,
        MyContract3.networks[id].address
    );

    const accounts = await web3.eth.getAccounts();

	//Triggering Event 1
    await contract.methods.payment(accounts[0], '1000000000000000000').send({
        from: accounts[1],
    });

	//Triggering Event 2
    await contract.methods.payment(accounts[1], '1000000000000000000').send({
        from: accounts[2],
    });

    const receipt = await contract.getPastEvents(
        'allEvents',
        {
            fromBlock: 0
        });

    console.log(receipt);
}

init();

In this script, we call twice the payment methods, and thus we emitted twice an event.

At the end, we call the getPastEvents method. As we can see, we ask for 'allEvents', and we want to search from the block 0, i.e. since the beginning. The 'allEvents' could have been replaced by the name of our event, which would have been 'MyPayment' in this case. You can try to replace 'allEvents' by 'MyPayment', and you will see the same output, including 2 additional events.

More info about getPastEvents method in web3 docs here.

[
  {
    logIndex: 0,
    transactionIndex: 0,
    transactionHash: '0xc8e47f0d25dad437ea866c63d65aee634d6b7cb2d3cef832bb337864a26e9767',
    blockHash: '0xd0f7c551453fdffd9cf2555c6cf2fb8a5506ccc6bba08b44841457902a175d3c',
    blockNumber: 15,
    address: '0xaE76c14CF39f32f88985264AC5471745F9150fE2',
    type: 'mined',
    id: 'log_39908cd0',
    returnValues: Result {
      '0': '1630595111',
      '1': '0x3577B769c0bA9a762211E6F6b006730f8399b231',
      '2': '0xbabbE01661c3ac49B3D5B10A890F8DDD5e60eC7f',
      '3': '1000000000000000000',
      date: '1630595111',
      from: '0x3577B769c0bA9a762211E6F6b006730f8399b231',
      to: '0xbabbE01661c3ac49B3D5B10A890F8DDD5e60eC7f',
      amount: '1000000000000000000'
    },
    event: 'MyPayment',
    signature: '0x3f149fb6578fdbf59cb6fffd764d2994d89b758e8dcadb7b14a8d37a05b90520',
    raw: {
      data: '0x0000000000000000000000000000000000000000000000000de0b6b3a7640000',
      topics: [Array]
    }
  },
  {
    logIndex: 0,
    transactionIndex: 0,
    transactionHash: '0x3d719b3ed229daf7b693560b46c3d8754859254d8fce47364416a2e390ffcb92',
    blockHash: '0x5ec007acc00ec909b97f14e0c961cb2c4249f8b270c24bafeaf5addf9277b21b',
    blockNumber: 16,
    address: '0xaE76c14CF39f32f88985264AC5471745F9150fE2',
    type: 'mined',
    id: 'log_f83c791c',
    returnValues: Result {
      '0': '1630595111',
      '1': '0x2804795Cfb92516345EABDE87A58b4341004b667',
      '2': '0x3577B769c0bA9a762211E6F6b006730f8399b231',
      '3': '1000000000000000000',
      date: '1630595111',
      from: '0x2804795Cfb92516345EABDE87A58b4341004b667',
      to: '0x3577B769c0bA9a762211E6F6b006730f8399b231',
      amount: '1000000000000000000'
    },
    event: 'MyPayment',
    signature: '0x3f149fb6578fdbf59cb6fffd764d2994d89b758e8dcadb7b14a8d37a05b90520',
    raw: {
      data: '0x0000000000000000000000000000000000000000000000000de0b6b3a7640000',
      topics: [Array]
    }
  }
]

👎 Limitations

• Asking to check events from block 0 on the Mainnet would take some time, since it has to scan all the blocks looking for our events.
• By default, the getPastEvents method is looking in the ‘earliest’ block (cf. doc here). Thus, to retrieve all events, we have to check from the initial block (fromBlock: 0). If we don’t define the block parameter, we will get the events from the earliest block (you can try ;-)).

☝️Alternative

• It’s possible to filter on specific event’s parameters, by adding the filter key to the getPastEvents method.
• In that case, you will also need to indicate the name of the event.

Example including a filter on the 'to' parameter:

const Web3 = require('web3');
const MyContract3 = require('./build/contracts/MyContract3.json');

const init = async() => {
    const web3 = new Web3('http://127.0.0.1:7545');
    
    const id = await web3.eth.net.getId();
    const contract = new web3.eth.Contract(
        MyContract3.abi,
        MyContract3.networks[id].address
    );

    const accounts = await web3.eth.getAccounts();

	//Triggering Event 1
    await contract.methods.payment(accounts[0], '1000000000000000000').send({
        from: accounts[1],
    });

	//Triggering Event 2
    await contract.methods.payment(accounts[1], '1000000000000000000').send({
        from: accounts[2],
    });

    const receipt = await contract.getPastEvents(
        'MyPayment',
        {
            filter:{
                to: '0x3577B769c0bA9a762211E6F6b006730f8399b231',
            }
        },
        {
            fromBlock: 0
        });

    console.log(receipt);
}

init();

To be able to use specific parameters as filters, we need to add the ‘indexed’ key in our Smart Contract.

The indexed variables must be chosen widely since we are limited to a maximum of 3.

From the Solidity doc:

"You can add the attribute indexed to up to three parameters which adds them to a special data structure known as “topics” instead of the data part of the log".

More info here.

Method 3 - WebSocket to read Real-Time events

What is a WebSocket?

"A WebSocket is a persistent connection between a client and server. WebSockets provide a bidirectional, full-duplex communications channel that operates over HTTP through a single TCP/IP socket connection. At its core, the WebSocket protocol facilitates message passing between a client and server".

I got this nice definition from this great article, which I recommend if you need more information about the subject.

The advantage of using WebSocket is that we can monitor events in real-time. To simulate this, we will use 2 different scripts. The first script will be listening to event in real-time, while the second script will trigger events.

What we will achieve:

Again, we will relaunch Ganache to get a clean blockchain (don't forget to migrate again using Truffle).

truffle migrate --reset

Script 1

We create the 'listener.js' script. Comments are following.

const Web3 = require('web3');
const MyContract3 = require('./build/contracts/MyContract3.json');

const init = async() => {
    const web3 = new Web3(
        new Web3.providers.WebsocketProvider(
            'ws://127.0.0.1:7545'
        )
    );

    const id = await web3.eth.net.getId();
    const contract = new web3.eth.Contract(
        MyContract3.abi,
        MyContract3.networks[id].address
    );

    contract.events.MyPayment({fromBlock: 0})
    	.on('data', event => console.log(event));
}

init();

Instead of using new Web3( 'Ganache address' ), we know use the WebsocketProvider.

At the end, we launch a 'listener' console.logging events when they occur.

We launch listener.js in a Terminal 1. You should see a script waiting.

Script 2

Our second script 'events.js' will be quite similar as the one used in the 2 previous methods, since it will only trigger twice the same events.

Here is the code. Comments are following.

const Web3 = require('web3');
const MyContract3 = require('./build/contracts/MyContract3.json');

const init = async() => {
    const web3 = new Web3('http://127.0.0.1:7545');
    
    const id = await web3.eth.net.getId();
    const contract = new web3.eth.Contract(
        MyContract3.abi,
        MyContract3.networks[id].address
    );

    const accounts = await web3.eth.getAccounts();

	//Triggering Event 1
    await contract.methods.payment(accounts[0], '1000000000000000000').send({
        from: accounts[1],
    });

    await sleep(5000);

	//Triggering Event 2
    await contract.methods.payment(accounts[1], '1000000000000000000').send({
        from: accounts[2],
    });
}

init();


function sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }

The only additional part is the 'sleep' method for 5 sec.

We are launching this script in a second terminal.

Now, we see the results: 1 event occurs live, then 5 sec later, the second one is displayed.

Hurra! It works! We successfully use 3 differents methods to listen to Smart Contract's events ! Congrats!

Sometimes it's necessary to load the Smart Contract with Ethers. Thus, we need to be able to send some token to our Smart Contract.

Since we are modifying the Blockchain, it will have to be mined, and by consequence it will cost some gas fees.

Actually, there are two ways to send Ether to a Smart Contract.

Method #1: Execute a Function

We will be using a different Smart Contract code for this new part. Thus, let's create a new file 'MyContract2.sol' in our contracts directory, and copy the code below. Comments are following.

pragma solidity >=0.4.16 <0.9.0;

contract MyContract2 {
    string public message;

    function sendEther() external payable {
        message = 'Ether sent!';
    }

    function() external payable {
        message = 'Fallback function!';
    }
}

• We define a new contract MyContract2 including 2 functions.
• We declare a public variable called message as a string type.
• Function sendEther() is simulating a payment, while the second function is a fallback function. It will be detailed in section.

Don't forget to adapt the migration file (2_contract_deploy.js) accordingly.

const MyContract = artifacts.require('MyContract');
const MyContract2 = artifacts.require('MyContract2');

module.exports = function(deployer){
    deployer.deploy(MyContract);
    deployer.deploy(MyContract2);
}

We simply added the MyContract2 to be deployed. If you want things cleaner, you can drop the MyContract since we won't use it anymore. It's up to you.

Now, we can migrate our new MyContract2.sol by running the following command in our terminal:

truffle migrate --reset

Among the results, you should see our MyContract2 deployment feedback:

Deploying 'MyContract2'
   -----------------------
   > transaction hash:    0x21f9754b72d2bfc595bda75c8a3c12e7fc9e0b415bf757c561d86b51d81e845d
   > Blocks: 0            Seconds: 0
   > contract address:    0xE5704600e4f2a0B2b2Fb5F07002F819D0EDC86A4
   > block number:        9
   > block timestamp:     1630438020
   > account:             0x8ba7dDC383130c3D5c3afC76AD3f3343571246E8
   > balance:             99.98120808
   > gas used:            209894 (0x333e6)
   > gas price:           20 gwei
   > value sent:          0 ETH
   > total cost:          0.00419788 ETH

Now, that we deployed our new MyContract2.sol successfully, we can move on our Javascript script. We will create a new index2.js and copy the below code. Comments are following.

const Web3 = require('web3');
const MyContract2 = require('./build/contracts/MyContract2.json');

const main = async() => {
    const web3 = new Web3('http://127.0.0.1:7545');

    const id = await web3.eth.net.getId();
    const contract = new web3.eth.Contract(
        MyContract2.abi,
        MyContract2.networks[id].address
    );

    const accounts = await web3.eth.getAccounts();
}

main();

Now, let's change this index2.js script to send 1 ETH to our Smart Contract MyContract2.sol.

const Web3 = require('web3');
const MyContract2 = require('./build/contracts/MyContract2.json');

const main = async() => {
    const web3 = new Web3('http://127.0.0.1:7545');

    const id = await web3.eth.net.getId();
    const contract = new web3.eth.Contract(
        MyContract2.abi,
        MyContract2.networks[id].address
    );

    const accounts = await web3.eth.getAccounts();

    const receipt = await contract.methods.sendEther().send({
        from: accounts[0],
        value: '1000000000000000000'
    });

    console.log(receipt);
    console.log(await contract.methods.message().call());
}

main();

Here we call our sendEther() methods, using 'send API'. The send method requires several parameters. We will be using the 2 following parameters (more details here in the doc):

• From: The address the transaction should be sent from.
• Value: The value transferred for the transaction in wei.

Note: 1 WEI = 10^(-18) ETH.

🚨 WARNING, there is a caveat here 🚨

• As you can see, the value we are transferring is written as a String type with quite a lot of 0.
• If we don’t write the value as above, the value will be in Wei (i.e. 10^-18 ETH). Thus, you should write 1 000 000 000 000 000 000 . The problem is that such big numbers are not managed by Javascript. That’s why the trick is to write it as a String type.
• If you have to perform math operations on this number, I recommend using the bn.js library. Here we keep it simple, and use the String version.

This being said, let's run our index2.js . We will see the following results:

{
  transactionHash: '0x033bf75f4e6891bdc130dc172ad18f0df9d08ab7675c0d6976f3e0ca21e35a57',
  transactionIndex: 0,
  blockHash: '0x2ac3d17d28f36a594cb778b631efe33f69a08bb88bfefc2e77190ef2cff2f035',
  blockNumber: 11,
  from: '0x8ba7ddc383130c3d5c3afc76ad3f3343571246e8',
  to: '0xe5704600e4f2a0b2b2fb5f07002f819d0edc86a4',
  gasUsed: 42365,
  cumulativeGasUsed: 42365,
  contractAddress: null,
  status: true,
  logsBloom: '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
  events: {}
}
Ether sent!

Hurra ! It works. We get the receipt of our transaction, as well as the message ‘Ether sent!’. Thus, we successfully sent 1 ETH to our Smart Contract (MyContract2).

Method #2: Send Ether Directly

The second method consists in sending Ether to our Smart Contract, without calling any function.

In our Smart Contract, if you remember, we added what we call a ‘fallback’ method. This method will be fired by default, if a wrong function name is called in our JS file, or if no function name is used. It serves as a fallback…

Here is the updated index2.js. Comments are following.

const Web3 = require('web3');
const MyContract2 = require('./build/contracts/MyContract2.json');

const main = async() => {
    const web3 = new Web3('http://127.0.0.1:7545');

    const id = await web3.eth.net.getId();
    const contract = new web3.eth.Contract(
        MyContract2.abi,
        MyContract2.networks[id].address
    );

    const accounts = await web3.eth.getAccounts();

    const receipt = await web3.eth.sendTransaction({
        from: accounts[0],
        to: contract.options.address,
        value: '1000000000000000000',
    });

    console.log(receipt);
    console.log(await contract.methods.message().call());
}

main();

Instead of calling a method from the Smart Contract, we call directly the sendTransaction method.

Thus we are not referencing a specific method from our Smart Contract. As parameters we are using:

• From: same as previous.
• To: the contract address we want to send ETH to: contract.options.address.
• Value: same as previous.

Our fallback function should be fired. Like the previous test, we are console.logging the receipt, as well as the value of our public message. It should print ‘Fallback function!’.

After running the code, we see the results below:

{
  transactionHash: '0xb5617cef2b868aef7c296d0a6a6141f0b0e73266c328f8371d7ef474107aadda',
  transactionIndex: 0,
  blockHash: '0x42a605890ba8ea0eb1046490ecdd76c4267c8eaff15b400a7fbf06acd1c60605',
  blockNumber: 12,
  from: '0x8ba7ddc383130c3d5c3afc76ad3f3343571246e8',
  to: '0xe5704600e4f2a0b2b2fb5f07002f819d0edc86a4',
  gasUsed: 28100,
  cumulativeGasUsed: 28100,
  contractAddress: null,
  logs: [],
  status: true,
  logsBloom: '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000'
}
Fallback function!

🎉 🥳 👯‍♂️ 🎈 Congratulations, it works , hurra ! We successfully sent 1 ETH to our Smart Contract using the fallback method.

Send Ether from an Account to another One

In this additional part, we just want to send some Ethers from an account to another one.

Here, we won't use any Smart Contract.

Let's say, we want to send 1 ETH from Ganache's account #1 to the #2.

Before we start, here are the balances of our Ganache's accounts.

The code is simple, I'm sure you could to do it by yourself :-). Comments are following.

const Web3 = require('web3');
const MyContract2 = require('./build/contracts/MyContract2.json');

const main = async() => {
    const web3 = new Web3('http://127.0.0.1:7545');

    const id = await web3.eth.net.getId();
    const contract = new web3.eth.Contract(
        MyContract2.abi,
        MyContract2.networks[id].address
    );

    const accounts = await web3.eth.getAccounts();

    const receipt = await web3.eth.sendTransaction({
        from: accounts[0],
        to: accounts[1],
        value: '1000000000000000000',
    });

    console.log(receipt);
}

main();

• We use the sendTransaction method without mentioning any Smart Contract here, and we give 3 parameters.
• From: the account from which the Ether will be withdrew.
• To: the credited account.
• Value: the amount of WEI we want to transfer. Again, we use the string format otherwise, we will have issue with Javascript (cf. Big Numbers).
• Remember, 1 WEI = 1*10^(-18) ETH

Here is our console.log receipt:

{
  transactionHash: '0xd4fb774a9dda670d887785adb36f03505e80a6ae45a2f6dc468ebcd9fedca372',
  transactionIndex: 0,
  blockHash: '0xd927a7cd0746670ae94a53c8ca0f6c23fd72d14b50d7ad6ef25b786e9c77befd',
  blockNumber: 1,
  from: '0x65ca5ecfd87faafe35f63244133efe9edf2abf55',
  to: '0x89d48bf3591db71c2ebd7be9ea86ce52442e474c',
  gasUsed: 21000,
  cumulativeGasUsed: 21000,
  contractAddress: null,
  logs: [],
  status: true,
  logsBloom: '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000'
}

And we can check our accounts balances from Ganache. We can see that 1ETH has been transfered from Account #1 to Account #2 !

Hurra! It works! We successfully transferred 1 ETH from Account 1 to Account 2.

In the previous lecture, we read data from our Smart Contract. In this lecture, we are going to write data in our Smart Contract. To perform this operation, we will be using the second API, called eth_sendTransaction.

Reminder: if we send transactions to a Smart Contract, we actually change the blockchain. If changes occur, it must be mined, thus it will cost some gas fees.

Send Transactions

Let's reuse our previous index.js initial code:

const Web3 = require('web3');
const MyContract = require('./build/contracts/MyContract.json');

const main = async() => {
    const web3 = new Web3('http://127.0.0.1:7545');

    const id = await web3.eth.net.getId();
    const contract = new web3.eth.Contract(
        MyContract.abi,
        MyContract.networks[id].address
    );
}

main();

In this case, we will be using the other method called 'methods.myMethod.send'. Unlike the call method, we cannot leave parameters blank here. Since the execution will cost some gas, we have to define what address we will pay with.

• From: the address from which we will send the transaction. In this case, we will use one among the 10 automatically generated addresses from Ganache. In production, we would have use Metamask for instance. This part will be covered in next parts of this tutorial.

It’s important to use an async function. Since we are using a local development environment, the mining will be executed immediately. But, on the Mainnet or any other Public Test environment, a transaction mining could take up to 15sec. Thus, it’s important to wait for the results.

Here is the code. Comments are following.

const Web3 = require('web3');
const MyContract = require('./build/contracts/MyContract.json');

const main = async() => {
    const web3 = new Web3('http://127.0.0.1:7545');

    const id = await web3.eth.net.getId();
    const contract = new web3.eth.Contract(
        MyContract.abi,
        MyContract.networks[id].address
    );

    const accounts = await web3.eth.getAccounts();

    const result1 = await contract.methods.get().call();

    const receipt = await contract.methods.set(100).send({
        from: accounts[0]
    });

    const result2 = await contract.methods.get().call();

    console.log(result1);
    console.log(receipt);
    console.log(result2);
    
}

main();

• First, we collect the generated accounts by Ganache, and store it in the array accounts. In this case, we will be using the first account, thus accounts[0].
• Next, we use our previous method, to check the value of data, with the get function. We will see that its value is 0 (cf. previous part).
• Then, we use the 'send' method, and we set the value to 100.
• Finally, we reuse the 'call' method to check if the data was properly updated to 100.

Here is our results:

0
{
  transactionHash: '0x9fbfd81501900d167879cd9bd5bda508726af622993eed09d297e7d7acfaa971',
  transactionIndex: 0,
  blockHash: '0x9ded0d30c75b6a881fbf3382973e81c6cdac070741912028a635652face5f5ec',
  blockNumber: 5,
  from: '0x8ba7ddc383130c3d5c3afc76ad3f3343571246e8',
  to: '0xdfc6bf4043de741a57f57d1f065e365849f5af7c',
  gasUsed: 41424,
  cumulativeGasUsed: 41424,
  contractAddress: null,
  status: true,
  logsBloom: '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
  events: {}
}
100

First, we see 0. Which is what we expected.

Then, we get the receipt of the transaction, which corresponds to the Transaction Hash:

• transactionHash: hexadecimal string that uniquely identifies the transaction on the blockchain. In prod, you could use that transactionHash in Etherscan to see your transaction details.
• blockHash: the hash of the block in which the transaction was mined,
• From: the address that sends the transaction. As you can see, we recognize our previously stated address there.
• To: is the recipient address of the transaction, which is our Smart Contract address,
• gasUsed: how much gas were used to mine the transaction

Finally, we get the updated value of 100.

As you can see in Ganache, our first account has less than 100 ETH now, since it paid the transaction.

🎉 🥳 👯‍♂️ 🎈 Congratulations! We successfully send our first transaction using the set() method from our Smart Contract. In the next lecture, we will send Ether to the Smart Contract !

In this chapter, we are going to interact with our Smart Contract.

First, we will use the Call API. This API will allow us to retrieve data from the Smart Contract.

Call API

We will start from the index.js script we developed in the past lecture.

const Web3 = require('web3');
const MyContract = require('./build/contracts/MyContract.json');

const main = async() => {
    const web3 = new Web3('http://127.0.0.1:7545');
    const id = await web3.eth.net.getId();
    const contract = new web3.eth.Contract(
        MyContract.abi,
        MyContract.networks[id].address
    );    
}

main();

Now, let's add a 'call' to our Smart Contract, using the 'methods.myMethod.call' methods from Web3. As we can see in the Web3 doc, we can add several parameters to this methods. For this first Call, we will keep things simple, and leave it blank.

Here is the code, and comments are following.

const Web3 = require('web3');
const MyContract = require('./build/contracts/MyContract.json');

const main = async() => {
    const web3 = new Web3('http://127.0.0.1:7545');

    const id = await web3.eth.net.getId();
    const contract = new web3.eth.Contract(
        MyContract.abi,
        MyContract.networks[id].address
    );

    const data = await contract.methods.get().call();
    console.log(data);
}

main();

• We use the contract.methods.get().call() to call the 'get' method we defined in our Smart Contract.
• Then, we console.log the result stored in data.

We can see the following result in the terminal:

0

Since, we didn't initialize our Smart Contract uint variable, this is empty, and our get function is thus returning 0.

🎉 🥳 👯‍♂️ 🎈 Congratulations! We successfully call our method get in our Smart Contract, directly from our index.js script. In the next lecture, we will send transaction !

In this chapter, we will learn how to create an instance of our Smart Contract. This part is required to interact with our contract.

What is a Contract Instance?

The Contract Instance is an object produced by the library Web3 creating a contract instance to interact with our Smart Contract.

Why don't we interact directly with the Smart Contract?

Well, each Smart Contracts are different and have their own functions, and addresses. So, we need to teach Web3 how to 'speak' with our Smart Contract.

To create our Contract Instance, Web3 is requiring 2 parameters:

Contract Address

A Contract Address is the address of the place where our Smart Contract is stored on the Ethereum Blockchain. It will allow us to send, or withdraw funds for instance.

Contract ABI

ABI stands for ‘Application Binary Interface’.

The Contract ABI is a JSON document describing all the functions, and variables used in the Smart Contract, callable from outside the Blockchain.

The ABI is generated by compiling/building our Smart Contract written in Solidity.

Smart Contract Development & Building

In this Serie, we won't cover the Solidity development part. Thus, we will use an already developed simple Smart Contract code.  Nevertheless, we will go the 3 steps of deploying a Smart Contract.

Step 1 - Code the Smart Contract

First, we are going to generate a basic development framework thanks to Truffle (installed in the part 1 of this serie). In our main directory, we run the following command:

truffle init

As a result you should have the following directory tree:

├── contracts
│   └── Migrations.sol
├── index.js
├── migrations
│   └── 1_initial_migration.js
├── node_modules
├── package-lock.json
├── package.json
├── test
└── truffle-config.js

In the Contracts directory, create a new file 'MyContract.sol' (.sol is standing for Solidity language).

To keep things simple, we will be using the Smart Contract used as example in Solidity documentation. We will just change a few things.

Initial code from Solidity documentation

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.16 <0.9.0;

contract SimpleStorage {
    uint storedData;

    function set(uint x) public {
        storedData = x;
    }

    function get() public view returns (uint) {
        return storedData;
    }
}

Here is the final code we will be using. Comments are following.

pragma solidity >=0.4.16 <0.9.0;

contract MyContract {
    uint data;

    function set(uint x) public {
        data = x;
    }

    function get() public view returns (uint) {
        return data;
    }
}

• First we define the Solidity version we are using.
• Then, we define a new contract, called MyContract.
• Next, we define an 'uint' (standing for Unsigned Integer) called data.
• The two functions below are respectively a setter function, i.e. replacing data value by x, and a getter function, i.e. returning data value.
• The public keywords mean that we can access these functions from outside the Smart Contract, thanks to Web3. Without that keyword, we could not access the variable or the function.

Step 2 - Code the Migration File

Now, we need to script a migration file. This script is telling Truffle how to migrate our Smart Contract to the blockchain.

In the migration directory, we create a new file named 2_contract_deploy.js (2 is important).

We add the following script in the migration file:

const MyContract = artifacts.require('MyContract');

module.exports = function(deployer){
    deployer.deploy(MyContract);
}

Step 3 - Compile & Migrate the Smart Contract

Now that we scripted our Smart Contract, and wrote our Migration file, we can launch the building process, and the migration.

In our main directory, we run the following command:

truffle migrate --reset

Comment

• the reset tag stands for resetting potential previous migration. In this first case, this is not required, but if you encounter error in the compilation, you would restart your truffle migration adding the --reset to start from scratch.

We will see the following results:

Compiling your contracts...
===========================
> Compiling ./contracts/Migrations.sol
> Compiling ./contracts/MyContract.sol
> Artifacts written to /Users/henririon/Documents/Tutorials/web3-tutorial/build/contracts
> Compiled successfully using:
   - solc: 0.5.16+commit.9c3226ce.Emscripten.clang



Starting migrations...
======================
> Network name:    'ganache'
> Network id:      5777
> Block gas limit: 6721975 (0x6691b7)


1_initial_migration.js
======================

   Deploying 'Migrations'
   ----------------------
   > transaction hash:    0x9907bdca7b17841fac28db587cf3b674481348e9bb730fb1e6b6722d1d09bc31
   > Blocks: 0            Seconds: 0
   > contract address:    0x3aa84f14eC87a764a4950AA2A1C1F4849bCC60d1
   > block number:        1
   > block timestamp:     1630419782
   > account:             0x8ba7dDC383130c3D5c3afC76AD3f3343571246E8
   > balance:             99.99616114
   > gas used:            191943 (0x2edc7)
   > gas price:           20 gwei
   > value sent:          0 ETH
   > total cost:          0.00383886 ETH


   > Saving migration to chain.
   > Saving artifacts
   -------------------------------------
   > Total cost:          0.00383886 ETH


2_contract_deploy.js
====================

   Deploying 'MyContract'
   ----------------------
   > transaction hash:    0xd24cdd7f0a11fe02a747fa3bc701a7de3a893c2995da145cbe360c57a93b47c4
   > Blocks: 0            Seconds: 0
   > contract address:    0xdfC6BF4043dE741A57f57d1f065e365849f5af7C
   > block number:        3
   > block timestamp:     1630419782
   > account:             0x8ba7dDC383130c3D5c3afC76AD3f3343571246E8
   > balance:             99.9933906
   > gas used:            96189 (0x177bd)
   > gas price:           20 gwei
   > value sent:          0 ETH
   > total cost:          0.00192378 ETH


   > Saving migration to chain.
   > Saving artifacts
   -------------------------------------
   > Total cost:          0.00192378 ETH


Summary
=======
> Total deployments:   2
> Final cost:          0.00576264 ETH

A few comments about this results:

• First, as indicated, Truffle compile our Smart Contract.
• Next, it starts the migration. First, the initial migration, and second our '2_contract_deploy.js'.
• For each migration, we got the transaction hash parameter informing us about the block number, the contract address, the total cost, etc.

Our Smart Contract has been successfully compiled, and migrated to our local blockchain, Ganache.

If we check our main directory, we should see a new directory called 'build'. Inside, we will find a file called MyContract.json, which is our Contract ABI.

As explained earlier, to create our Smart Contract Instance, Web3 is requiring 2 parameters: the Contract Address, and the Contract ABI. We now have both, and we can start coding.

Create our Smart Contract Instance

Now, that we generate our Smart Contract ABI, we can actually retrieve both parameters we need inside the generated MyContract.json file.

If we open the ABI Json file, we can see at the end of the file, the following piece of code:

[...]

"networks": {
    "5777": {
      "events": {},
      "links": {},
      "address": "0xdfC6BF4043dE741A57f57d1f065e365849f5af7C",
      "transactionHash": "0xd24cdd7f0a11fe02a747fa3bc701a7de3a893c2995da145cbe360c57a93b47c4"
    }
    
[...]

The mentioned address is our Smart Contract address deployed in our local Blockchain, Ganache.

Now, we have everything to create our Smart Contract instance.

Here is the complete code. Comments are following.

const Web3 = require('web3');
const MyContract = require('./build/contracts/MyContract.json');

const main = async() => {
    const web3 = new Web3('http://127.0.0.1:7545');

    const id = await web3.eth.net.getId();
    const contract = new web3.eth.Contract(
        MyContract.abi,
        MyContract.networks[id].address
    );

    console.log(contract);
}

main();

• We import MyContract.json, our Contract ABI as MyContract.
• Then, we use the web3.eth.net.getId() methods to retrieve the current Network ID. It will help us finding our Smart Contract address.
• Next we create our Contract Instance by giving the two required parameters: the Contract ABI, and the Contract address.
• To check if everything is fine we console.log our contract instance.

🎉 🥳 👯‍♂️ 🎈 Congratulations! We successfully instantiate our first Smart Contract. Let's move on and interact with our Smart Contract now.

At the end of this chapter, we will be able to connect our code to our local blockchain (Ganache), and retrieve account balance in Ether.

Introduction

In this part, we are going to configure Web3 to enable communication with Ganache, or any other nodes.

To allow interactions, Web3 is requiring a 'provider'.

What is a Web3 provider?

A provider is a data structure providing a bridge with the publicly reachable Ethereum nodes. In other words, a provider is how Web3 talks to the blockchain (more info here).

The provider actually sends the call in JSON-RPC to the Ethereum nodes. Thanks to this design, the users keep flexibility, and is able to decide what wallet he is going to use.

Usually, the Ethereum wallet exposes the provider object as a global object in Javascript. In any case, our dApp will test whether the provider is public, and if it is, we will create a Web3 instance to connect to the blockchain using the wallet provider.

Let's dive in the code

In our main directory, where we installed our dependencies, we create a file 'index.js'.

touch index.js

In this file, let's write the following code. Comments are following.

const Web3 = require('web3');
const web3 = new Web3('http://127.0.0.1:7545');

• We import the library in our code. It's important to write Web3 with an Uppercase to differentiate the Object, from the instance we create after.
• Finally, we instantiate Web3 using the RPC Service url provided by Ganache http://127.0.0.1:7545.

We are now connected to our local Blockchain.

Smoke Test

Now we are connected, let's test our code. We will try to retrieve the Ether Balance from 1st account generated by Ganache.

Here is the code. Comments are following.

const Web3 = require('web3');
const web3 = new Web3('http://127.0.0.1:7545');

const main = async() => {
    const address = '0x8ba7dDC383130c3D5c3afC76AD3f3343571246E8';
    const balance = await web3.eth.getBalance(address);
    console.log(balance);
}

main();

• We define a async function called main.
• Then, we copy the first account address provided by Ganache.

• Finally, we use the web3.eth.getBalance(address [, defaultBlock] [, callback]) method allowing us to retrieve the balance for specific account.

After launching the code, we will see the following result in the Terminal

100000000000000000000

Why don’t we see 100 ETH?

By default, the getBalance function returns the value in Wei, which corresponds to 10^-18 ETH.

We can use the 'utils' toolbox from web3 to convert this Wei amount into Eth.

const Web3 = require('web3');
const web3 = new Web3('http://127.0.0.1:7545');

const main = async() => {
    const address = '0x8ba7dDC383130c3D5c3afC76AD3f3343571246E8';
    const balanceWei = await web3.eth.getBalance(address);
    const balanceEth = await web3.utils.fromWei(balanceWei);
    console.log(balanceEth);
}

main();

After running that script, we will see 100 ETH as a result.

100

🎉 🥳 👯‍♂️ 🎈 Congratulations! We successfully setup our provider, and communicate with Ganache !

Let's move on to the next part.