Ethereum sidechain tutorial

Because sidechains are EVM-compatible, they are considered a useful scaling solution for Ethereum-native dapps. With your dapp on a sidechain, users can enjoy lower gas fees and faster transactions, especially if Mainnet is congested. However, as explained previously, using a sidechain involves significant trade-offs.

Each sidechain is responsible for its security and doesn't inherit Ethereum's security properties. This increases the possibility of malicious behavior which can affect your users or put their funds at risk. Asset movement In order for a separate blockchain to become a sidechain to Ethereum Mainnet it needs the ability to facilitate the transfer of assets from and to Ethereum Mainnet.

This interoperability with Ethereum is achieved using a blockchain bridge. Bridges use smart contracts deployed on Ethereum Mainnet and a sidechain to control the bridging of funds between them. While bridges help users move funds between Ethereum and the sidechain, the assets are not physically moved across the two chains. Instead, mechanisms that typically involve minting and burning are used for transferring value across chains.

More on how bridges work. Pros and cons of sidechains Pros The technology underpinning sidechains is well-established and benefits from extensive research and improvements in design. Sidechains trade off some measure of decentralization and trustlesness for scalability.

Sidechains support general computation and offer EVM compatibility they can run Ethereum-native dapps. A sidechain uses a separate consensus mechanism and doesn't benefit from Ethereum's security guarantees. Source: Unsplash. There are some proposed solutions, but they are compromising the most basic principles, the aforementioned decentralization and security.

Utilizing altcoins was one of the first theorized solutions of the scalability problem. The principle is to abandon the idea of one blockchain, where all the operations are made, and instead utilize a model of several altcoins co-existing, of which every altcoin uses its own ledger. This reduction of operations per blockchain and creation of separate blockchains — sidechains for every dapplication should help the scalability of any blockchain. Because of the lower number of nodes per network in every such sidechain comes the higher probability of attacks and noxious users in the network.

Thus, such a solution, although solving the scalability problem, seriously compromises its security. There is another proposed solution — Increasing block size. If the Ethereum community would vote for increasing the block size, all nodes on the network would process all the operations on the network as they were, but they would process more transactions in the same time.

The bigger block size requires more energy though. It would mean that only a small number of miners would be able to continue operating. The future would be that only a small group of supercomputers will run the network, leading to a centralized network. The main goal of the blockchain technology has always been decentralization and security.

The main obstacle now for scalability is the fact that every node in network processes every transaction. Here comes the trilemma problem. There are four protocols in development right now, which are solving this problem right now — Sharding, Plasma, Raiden. In this article we will discuss sidechains and scalability solution named Plasma briefly , introduced Plasma and sidechains are in principle branches of several chains connected to their mother-chain. The processing of smart contracts will work the same way as on the Etherum network with the exception that only the result is saved on the main chain, i.

We can imagine it as a hierarchical structure of blockchain, periodically processing information back to the mother chain. Ultimately it shows us that thanks to the minimal number of nodes in the sidechain and because of the faster speed and negligible costs of gas we can process more complex operations, i.

This enables developers to create whole applications based on the blockchain technology with thousands of users, without the issue of scalability or other limitations. What are the main advantages of Plasma? This will save a vast amount of energy and the memory capacity on the main-chain nodes.

Sidechain tutorial ethereum best crypto calculator

That result.. soft fork ethereum apologise, but

The bigger block size requires more energy though. It would mean that only a small number of miners would be able to continue operating. The future would be that only a small group of supercomputers will run the network, leading to a centralized network. The main goal of the blockchain technology has always been decentralization and security.

The main obstacle now for scalability is the fact that every node in network processes every transaction. Here comes the trilemma problem. There are four protocols in development right now, which are solving this problem right now — Sharding, Plasma, Raiden. In this article we will discuss sidechains and scalability solution named Plasma briefly , introduced Plasma and sidechains are in principle branches of several chains connected to their mother-chain.

The processing of smart contracts will work the same way as on the Etherum network with the exception that only the result is saved on the main chain, i. We can imagine it as a hierarchical structure of blockchain, periodically processing information back to the mother chain. Ultimately it shows us that thanks to the minimal number of nodes in the sidechain and because of the faster speed and negligible costs of gas we can process more complex operations, i.

This enables developers to create whole applications based on the blockchain technology with thousands of users, without the issue of scalability or other limitations. What are the main advantages of Plasma? This will save a vast amount of energy and the memory capacity on the main-chain nodes. Plasma is compatible with different on-chain scalability solutions such as sharding, different block sizes etc. Plasma in use — Plasma Cash and DAppChain Right now, the whole dapplication ecosystem suffers from inefficiency, in the way of mixing the financial transactions with transactions in the form of launching functions on smart contracts and interacting with dapplication functionality, be it an instruction in the smart contract or transferring millions of dollars between wallets, every such transaction is processed with the same level of security.

This is not a problem in itself. The security is always on the first place, as a smart contract command can be worth millions. Is like paying for a premium functionality, whilst only needing a basic one. Not every transaction in dapplication requires the same level of security.

Attacker or a hacker has much less interest in exploiting and harm transactions within dapplication where we talk about micro-transactions, than in for example attacks like double-spending, which can several million euros in value. DAppChain as another layer above Ethereum blockchain. The main philosophy of Loom DappChain is to create a separate sidechain for every dapp, which functions parallel to the Ethereum mainchain and with assets secured through the Plasma technology.

We'll also examine key concepts like "what is a blockchain? You can watch me build the full decentralized application in the 2-hour video above. I'll also guide you through the step-by-step instructions in this tutorial. Before we start building our dApp, let's examine some key concepts.

If you are eager to start coding, feel free to skip ahead to the next part of the tutorial. What is a Blockchain? Normally when you interact with a web application, you use a web browser to connect to a central server over a network. All the code of this web application lives on this central server, and all the data lives in a central database.

Anytime you transact with your application, must communicate with this central server on the web. The source code on the web server could also be changed at any time. We want to build it on the blockchain where anyone connected to the network can participate in the election.

We want to ensure that their votes are counted, and that they are only counted once. Instead of having a network, a central server, and a database, the blockchain is a network and a database all in one. A blockchain is a peer-to-peer network of computers, called nodes, that share all the data and the code in the network. You now have a copy of all the data and the code on the blockchain. There are no more central servers.

Just a bunch of computers that talk to one another on the same network. Instead of a centralized database, all the transaction data that is shared across the nodes in the blockchain is contained in bundles of records called blocks, which are chained together to create the public ledger. This public ledger represents all the data in the blockchain. All the data in the public ledger is secured by cryptographic hashing, and validated by a consensus algorithm. Nodes on the network participate to ensure that all copies of the data distributed across the network are the same.

What would it look like for a user of our application to vote on the blockchain? Well, for starters, the user needs an account with a wallet address with some Ether, Ethereum's cryptocurrency. Once they connect to the network, they cast their vote and pay a small transaction fee to write this transaction to the blockchain. Whenever the vote is cast, some of the nodes on the network, called miners, compete to complete this transaction. The miner who completes this transaction is awarded the Ether that we paid to vote.

As a recap, when I vote, I pay a gas price to vote, and when my vote gets recorded, one of the computers on the network gets paid the my Ether fee. I in turn am confident my vote was recorded accurately forever. What is a Smart Contract?

Well, the Ethereum blockchain allows us to execute code with the Ethereum Virtual Machine EVM on the blockchain with something called a smart contract. Smart contracts are where all the business logic of our application lives. Smart contracts are in charge of reading and writing data to the blockchain, as well as executing business logic. Smart contacts are written in a programming language called Solidity , which looks a lot like Javascript.

The function of smart contracts on the blockchain is very similar to a microservice on the web. If the public ledger represents the database layer of the blockchain, then smart contracts are where all the business logic that transacts with that data lives. Also, they're called smart contracts because they represent a covenant or agreement.

In the case of our voting dApp, it is an agreement that my vote will count, that other votes are only counted once, and that the candidate with the most votes will actually win the election. Now let's jump in and start programming! We'll build a client-side application that will talk to our smart contract on the blockchain. This client-side application will have a table of candidates that lists each candidate's id, name, and vote count.

It will have a form where we can cast a vote for our desired candidate. It also shows the account we're connected to the blockchain with under "your account". Installing Dependencies The accompanying video footage for this portion of the tutorial begins at In order to build our dApp, we need a few dependencies first.

It provides a suite of tools that allow us to write smart contacts with the Solidity programming language. It also enables us to test our smart contracts and deploy them to the blockchain. It also gives us a place to develop our client-side application. You can install Ganache by downloading it from the Truffle Framework website. It will give us 10 external accounts with addresses on our local Ethereum blockchain. Each account is preloaded with fake ether.

Metamask The next dependency is the Metamask extension for Google Chrome. In order to use the blockchain, we must connect to it remember, I said the block chain is a network. Reference the video walk through if you get stuck! Syntax Highlighting The dependency is optional, but recommended. I recommend installing syntax highlighting for the Solidity programming language. Smoke Test - Step 1 The accompanying video footage for this portion of the tutorial begins at You can download the code for this portion of the tutorial here.

Feel free to use these as a reference point if you get stuck! First, find where you downloaded Ganache , and open it. Now that Ganache has booted, you have a local blockchain running. Ganache gave us 10 accounts preloaded with fake Ether this isn't worth anything on the main Ethereum network. Each account has a unique address and a private key. Each account address will serve as a unique identifier for each voter in our election.

We'll be using the Pet Shop box for this tutorial. We already have a Migration contract that handles our migrations to the blockchain. These migrations are similar to other web development frameworks that require migrations to change the state of a database. Whenever we deploy smart contracts to the blockchain, we are updating the blockchain's state, and therefore need a migration.

This smart contract will contain all the business logic of our dApp. It will be in charge reading from and write to the Ethereum blockchain. It will allow us to list the candidates that will run in the election, and keep track of all the votes and voters.

It will also govern all of the rules of the election, like enforcing accounts to only vote once. Open the file and start with the following code: pragma solidity 0. We start by declaring the solidity version with the pragma solidity statement. Next, we declare the smart contract with the "contract" keyword, followed by the contract name.

Next, we declare a state variable that will store the value of the candidate name. State variables allow us to write data to the blockchain. We have declared that this variable will be a string, and we have set its visibility to public.

Because it is public, solidity will give us a getter function for free that will allow us to access this value outside of our contract. We'll see that in action later in the console! Then, we create a constructor function that will get called whenever we deploy the smart contract to the blockchain.

This is where we'll set the value of the candidate state variable that will get stored to the blockchain upon migration. Notice that the constructor function has the same name as the smart contract. This is how Solidity knows that the function is a constructor. Now that we've created the foundation for the smart contract, let's see if we can deploy it to the blockchain.

In order to do this, we'll need to create a new file in the migrations directory. Next, we add it to the manifest of deployed contracts to ensure that it gets deployed when we run the migrations. From the console, run this code: Election. We retrieved a deployed instance of the contract with the deployed function, and assigned it to an app variable inside the promise's callback function.

This might look a little confusing at first, but you can reference the console demonstration in the video at for further explanation. Now we can read the value of the candidate variable like this: app. You've just written your first smart contract, deployed to the blockchain, and retrieved some of its data.

List Candidates - Step 2 The accompanying video footage for this portion of the tutorial begins at Now that everything is set up properly, let's continue building out the smart contact by listing out the candidates that will run in the election.

We need a way to store multiple candidates, and store multiple attributes about each candidate. We want to keep track of a candidate's id, name, and vote count. Solidity allows us to create our own structure types as we've done for our candidate here. We specified that this struct has an id of unsigned integer type, name of string type, and voteCount of unsigned integer type. Simply declaring this struct won't actually give us a candidate.

We need to instantiate it and assign it to a variable before we can write it to storage. The next thing we need is a place to store the candidates. We need a place to store one of the structure types that we've just created. We can do this with a Solidity mapping. A mapping in Solidity is like an associative array or a hash, that associates key-value pairs. This essentially gives us an id-based look up for each candidate. Since this mapping is assigned to a state variable, we will write data to the blockchain anytime we assign new key-value pairs to it.

Next, we set this mapping's visibility to public in order to get a getter function, just like we did with the candidate name in the smoke test. That's because any key in a mapping that hasn't been assigned a value yet will return a default value an empty candidate in this case.