Ethereum-Constantinople will be coming soon, and many of you are asking what this means and whether you need to do something to prepare.
Tl; DR: If you are just the owner of ETH, you do not need to do anything to prepare for this update.
What is fork?
Simply put, fork is update network. This is very similar to how you update your computer or your applications to increase their security or get new features.
Have you ever tried to open a Word document or another file, and it looked very strange because it was created in a newer version of Word? Perhaps the comments were lost or displayed in a strange font? Hard fork looks like this. If people use old software and new software and try to communicate with each other, things may be missing or unreliable.
This is because the blockchain is decentralized and works on a ton of computers at the same time. Instead of e-mailing this Word document from one person to another, everyone can access the most modern “Word document” (also known as the blockchain) at the same time.
Thus, in order to make sure that everything is not so bad, everyone who starts the software of the blockchain (aka “node”) should update it. Thus, all have the same new features and security features and play by the same rules.
Why is it called fork?
It is called a fork, because, like a fork in the road, one chain of blocks is divided into two chains, separate from the blocks.One path or chain are people playing by the old rules. The second chain of people playing by the new rules.
With non controversial hard forks, most people stop running old software. No one adds new blocks to this chain. The chain naturally slows down and then dies. There is no value for coins on the old chain.
However, if updating the plug is controversial (this means that there are people who disagree with the changes that are made), how the “ways” of the plug can continue to live and matter. This is how ETC came from ETH and BCH from BTC.
What is Constantinople?
Constantinople is just the name given to this update of the Ethereum network. The updates (below) are not controversial, and everyone is expected to accept the Ethereum blockchain on this new path.
As a result, as previously uncontroversial updates (Homestead in 2016 and Byzantium in 2017), this hard fork will lead to the fact that two chains with the old chain die almost immediately. As well as the updates that were made earlier, the average person will not notice any changes or that a fork in the road has occurred.
This new ETH blockchain includes several new implementations of Ethereum Improvement Proposal (EIP), which are designed to ... improve Ethereum.
Should I do something with this new blockchain or transfer my ETH?
No. Your ETH will exist simultaneously in the new ETH chain and the old ETH chain. All exchanges (Coinbase, Kraken, ShapeShift), services (MyCrypto, MetaMask, Trust Wallet) and node providers (Infura, Etherscan, Quiknode) will update their nodes, so you will simply use the updated nodes / software without even noticing it.
If a you start a site (for example, you work in Infura or use Geth or Parity on your home computer), you will need to update the software to the latest version.Again, for ordinary users, you do not need to do anything, and this will be a painless and smooth transition.
If hard fork was controversial, it would be a different story.
What EIP are included?
EIP 145: EVM Bitwise Shift Instructions
- Provide your own bitwise offset at a cost along with other arithmetic operations.
- There are no bit shift operators in EVM, but other logical and arithmetic operators are supported.Shift operations can be implemented using arithmetic operators, but this has a higher cost and requires more processing time from the host. The introduction of SHL and SHR using arithmetic costs 35 gases to each, and in the proposed instructions, 3 gases
- Tl; DR: adds built-in functionality to the protocol so that it is cheaper and easier to do certain things in the chain. 😉
EIP 1014: Skinny CREATE2
- Adds a new opcode to 0xf5, which takes 4 stack arguments: endowment, memory_start, memory_length, salt.Behaves identical to CREATE, except when using
keccak256 (0xff ++ address ++ salt ++ keccak256 (init_code)) [12:]instead of the usual sensh-and-nonce-hash as the address at which the contract is initialized.
- Allows you to interact with addresses that do not yet exist in the chain, but which you can rely on to eventually contain only the code created by a specific piece of initialization code.
- This is important for use cases of a state channel that are associated with counterfeit interaction with contracts.
- Tl; DR: makes it so that you can interact with addresses that have not yet been created due to status channels. 😉
EIP 1052: EXTCODEHASH opcode
- This EIP indicates the new opcode, which returns the contract code keccak256 hash.
- Many contracts must verify the bytecode of the contract, but not necessarily the bytecode itself. For example, a contract may want to check whether the byte code of another contract is one of the set of permitted implementations, or it can perform code analysis and whitelist any contract with the corresponding byte code if the analysis has passed.
- Currently, contracts can do this using the EXTCODECOPY opcode, but this is expensive, especially for large contracts, in cases where only a hash is required. As a result, we propose a new transaction code EXTCODEHASH, which returns the keccak256 hash of the contract byte code.
- Tl; DR: makes it cheaper (less gas required) to do certain things in the chain. 😉
EIP 1283: Clean Gas Accounting for SSTORE without dirty cards
- This EIP offers clean gas metering changes for SSTORE's opcode, which allows new contract storage methods to be used and to reduce excessive gas costs if this is not consistent with most implementations.
- Tl; DR: makes it cheaper (less gas is required) to perform certain tasks in the chain, especially things that are currently “excessively” expensive. 😉
EIP 1234: Delay of a bomb in Constantinople and adjustment of unit remuneration
- The average blocking time is increased due to the slow acceleration of the bomb complexity (also known as the "ice age"). In this EIP, it is proposed to postpone the bomb complexity by approximately 12 months and reduce the block rewards using the plug of Constantinople, the second part of the Metropolis fork.
- Tl; DR: make sure that we do not freeze the blockchain before the proof of the bet is ready and implemented. 😉
Here is a short video that describes 4 of 5 EIP updates:
- The video was released before the Ethereum Foundation added the 5th EIP to the update, EIP-1283.
Will this affect the transaction / confirmation time?
- The blocking time should remain ~ 15 seconds. Full PoS (in the future) may change this, but there will be some delay with PoW, and a higher transaction rate can create blocks with unreliable transactions.
Will this affect the cost of the transaction?
- The cost depends on the number of transactions. Some of the EIPs are optimizing interaction under a smart contract, so I hope that the cost of a transaction under a smart contract will decrease. However, we don’t know whether another dapp will appear, such as CryptoKitties, which overloads the network and increases the charge.
Will this affect the number of transactions per second?
- There will be the same average Tx's / second, but with the way the EIP-1024 optimizes state channels, we need to see some second-level solutions that are starting to take effect (for example, OmiseGo, Loom Network, Raiden, etc.)
Is this a update of proof of stake?
- Not yet, many tests still underway. One of the reasons for EIP-1234 is to reduce blocking rewards in order to delay a bomb of complexity. In the end, we will have a chain of a lighthouse and a chain of sharding.
Here is the progress tracker used for Constantinople. . This is a great resource if you want to learn about EIP at a technical level.
Thanks to redditor / u / cartercarlson, who wrote the resume and kindly gave us permission to borrow it. We changed and added a lot.
Any questions? Feel free to contact us on Twitter or via email.
Thanks for reading! See you on the 16th!