Welcome to another article in ethereum programming basics. In the previous articles we have seen the process and the basic tools to develop a decentralized application, and in today’s article we will see how to deploy a dapp in a public testnet, I will also give you some resources you can use to strenghten your skills as an ethereum developer.
The main goal of Infura is to provide instant access to the Ethereum and IPFS networks without all the hassle of setting up your own Ethereum or IPFS node.
Infura is powered by a cutting-edge microservice-driven architecture that dynamically scales…
If you have been trying lately to build your dapp front-end with React and Redux, and you’ve realized that you couldn’t just focus on what the dapp is supposed to do, because you had to spend a lot of time configuring the application to provide the components with web3 and contracts instances and keep data synchronized with the blockchain, then this is the right place for you, drizzle store is exactly what you need in this case. So, let’s see how it works and how to use it with a dapp front-end.
The main purpose of drizzle store is to…
Welcome to another article in the Learn Solidity series, which aims to introduce you to Ethereum programming.
In the last article, we have seen how to use web3.js to build a dapp. In today’s article, we will see how to use web3.js to read events from the blockchain.
Events in Solidity act like the logging functionality that you’re used to with other languages, except that instead of logging to the console or to a file, the logs are saved in the Ethereum blockchain. In the following sections we will see:
logsBloom
is…Welcome to another installment of the Learn Solidity series. In the last article, we saw how to implement the factory pattern. If you’ve been following from the beginning of this series, then you’ve got the basics down and can start writing your own smart contracts.
Therefore, today I would like to give you the big picture of building decentralized applications and introduce you to web3.js — the missing piece to start building your own dapps.
Before diving into the details of what web3.js …
Welcome to another installment of the Learn Solidity series. In the previous article, we discussed how to create a smart contract from within another smart contract. Today, we will take a look at a typical use case for this scenario.
The idea of the factory pattern is to have a contract (the factory) that will carry the mission of creating other contracts. The main motivation for this pattern in class-based programming comes from the single-responsibility principle (a class does not need to know how to create instances of other classes), and this pattern provides an abstraction for the constructor.
Welcome to another article in the “Learn Solidity” series. In the last article, we saw how to use functions and applied everything we’ve learned so far to build a multisignature wallet.
In this article, we’ll see how to create a contract from within another contract — and how to define abstract contracts and interfaces.
Contracts can be created via Ethereum transactions or from within Solidity contracts using the new
keyword, which deploys a new instance of that contract and returns its address.
Let’s take a closer look at how this actually works by examining the example given in the Solidity…
Welcome to another article in the Learn Solidity series, in the previous article we concluded with variables, and today I will introduce you to functions and modifiers, which will give you by the end of this article all the pieces to build a multisignature wallet as we will see in the practice section.
Functions in Solidity have the following form :
function function_name(<param_type> <param_name>) <visibility> <state mutability> [returns(<return_type>)]{ ... }
They can be written either outside (free function) or inside a contract.
A function can return an arbitrary number of values as output. …
Welcome to another article in the Learn Solidity series. In the last article, we have seen how data location works and when you can use each of the three locations: memory
, storage
, and calldata
.
In this article, we will continue our journey of learning about variables in Solidity. This time we will focus on reference types, which should explicitly specify the data location, as we mentioned in previous articles. We will also see how you can define mappings, enumerations, and constants.
In Solidity we have two types of arrays: storage arrays and memory arrays.
These arrays are declared as state…
Welcome to another article in the Learn Solidity series. As I promised in the last article, we will see how data storage works in Solidity.
Before talking about data storage in Solidity, I would like to introduce a few things about the Ethereum virtual machine to make things clearer.
The internal workings of EVM:
Welcome to the second article in the Learn Solidity series. If you haven’t read the first one, I highly recommend that you do in order to set up your development environment and write and deploy your first contract.
In this article, we will have a look at variables in Solidity, their types, how they are stored, and how you can use them.
In Solidity we have two types of variables :
These variables are declared outside of functions (like the attributes of a class) and are stored permanently in the Ethereum blockchain, more specifically in the storage Merkle Patricia tree…