nethermindeth/nethermind

A robust execution client for Ethereum node operators.

nethermind's Issues

Refactor EVM to use error codes instead of exceptions for byte code processing.

We have already done it for most of the cases but still have a few where we actually throw exceptions (e.g. overflow, underflow).
We want to only use exception for client failures. EVM exceptions should be error codes / included in execution status.

Fix the storage display in EVM traces

At the moment the storage data is not displayed separately for different call depths which leads to incorrect results in trace files

Implement eth63 / fast sync

Integrate Solidity compiler with Nethermind

Example test scenario would be running the tutorial below with Nethermind:
https://github.com/ethereum/go-ethereum/wiki/Contract-Tutorial

EIP-145

https://eips.ethereum.org/EIPS/eip-145

Implement int256 for use in Nethermind

I assume that we can base the code on Dirichlet Numerics and expand it for int256
https://github.com/ricksladkey/dirichlet-numerics

Following the implementation and set of tests we would replace all references in EVM.

PoS support / beacon chain

https://notes.ethereum.org/SCIg8AH5SA-O4C1G1LYZHQ

LogTests failing after memory UInt256 changes

LogTests.Test(log0_logMemStartTooHigh_d0g0v0_Byzantium) |  
LogTests.Test(log0_logMemStartTooHigh_d0g0v0_EIP150) |  
LogTests.Test(log0_logMemStartTooHigh_d0g0v0_EIP158) |  
LogTests.Test(log0_logMemStartTooHigh_d0g0v0_Frontier) |  
LogTests.Test(log0_logMemStartTooHigh_d0g0v0_Homestead) |  
LogTests.Test(log1_logMemStartTooHigh_d0g0v0_Byzantium) |  
LogTests.Test(log1_logMemStartTooHigh_d0g0v0_EIP150) |  
LogTests.Test(log1_logMemStartTooHigh_d0g0v0_EIP158) |  
LogTests.Test(log1_logMemStartTooHigh_d0g0v0_Frontier) |  
LogTests.Test(log1_logMemStartTooHigh_d0g0v0_Homestead) |  
LogTests.Test(log2_logMemStartTooHigh_d0g0v0_Byzantium) |  
LogTests.Test(log2_logMemStartTooHigh_d0g0v0_EIP150) |  
LogTests.Test(log2_logMemStartTooHigh_d0g0v0_EIP158) |  
LogTests.Test(log2_logMemStartTooHigh_d0g0v0_Frontier) |  
LogTests.Test(log2_logMemStartTooHigh_d0g0v0_Homestead) |  
LogTests.Test(log3_logMemStartTooHigh_d0g0v0_Byzantium) |  
LogTests.Test(log3_logMemStartTooHigh_d0g0v0_EIP150) |  
LogTests.Test(log3_logMemStartTooHigh_d0g0v0_EIP158) |  
LogTests.Test(log3_logMemStartTooHigh_d0g0v0_Frontier) |  
LogTests.Test(log3_logMemStartTooHigh_d0g0v0_Homestead) |  
LogTests.Test(log4_logMemStartTooHigh_d0g0v0_Byzantium) |  
LogTests.Test(log4_logMemStartTooHigh_d0g0v0_EIP150) |  
LogTests.Test(log4_logMemStartTooHigh_d0g0v0_EIP158) |  
LogTests.Test(log4_logMemStartTooHigh_d0g0v0_Frontier) |  
LogTests.Test(log4_logMemStartTooHigh_d0g0v0_Homestead)

Implement UInt256 Remainder

The code is in a separate solution - Nethermind.Dirichlet which is a fork of the UInt128 library

Whisper / SHH support

Below you will find more information on what is expected:

Whisper spec and documentation can be collected from various Ethereum sites. Among them:

• https://github.com/ethereum/wiki/wiki/Whisper
• https://github.com/ethereum/go-ethereum/wiki/Whisper-v6-RPC-API

It is encouraged to contact other core devs who are working on Whisper to exchange implementation ideas and seek help.

Best place to seek help from the Nethermind team is Gitter:
https://gitter.im/nethermindeth/nethermind

What is expected for the pull request to be approved:

1. Write P2P subprotocol handler for Whisper
2. Create Whisper messages and serializers based on the approach used for Eth protocol
3. Support Whisper RPC commands as an RPC module (extending ModuleBase)
4. Create a wnode like diagnostic tool
5. Create an integration test with 4 nodes exchanging messages
6. Write unit tests for protocol handler, messages and message serializers

Nethermind core team will be glad to implement / link any cryptographical constructs necessary for the implementation of Whisper.

EIP-1052

https://eips.ethereum.org/EIPS/eip-1052

EIP-210

https://eips.ethereum.org/EIPS/eip-210

Remove Hex class

It was introduced early to support easier testing and some strong typing but it seems to be more confusing than helpful nowadays. Also expected performance benefits are not there as string and byte[] contexts are mostly exclusive.

EIP-1283

https://eips.ethereum.org/EIPS/eip-1283

Add BenchmarkDotNet example for consistent use

Need a guideline on use of BenchmarkDotNet inside Nethermind - single example and documentation for use in Nethermind project.

Plasma Cash support with Nethermind

Implement LES protocol

https://github.com/ethereum/wiki/wiki/Light-client-protocol

Implement signed Int256 in Dirichlet

The code is in a separate solution - Nethermind.Dirichlet which is a fork of the UInt128 library.
There is code for unsigned UInt and signed one has never been written - both are needed for an improved EVM performance.

Implement Clique

As you can see below - Gitcoin bounty has been funded for this issue (kudos to Gitcoin team).
Below you will find more information on what is expected:

Clique spec is available here:
ethereum/EIPs#225

Best place to seek help from the team is Gitter:
https://gitter.im/nethermindeth/nethermind

1. Write ISealEngine implementation representing Clique block sealing.
2. Write IBlockValidator / IBlockHeaderValidator to validate properly repurposed fields in BlockHeader
3. Make necessary changes to IChainSpecLoader to allow different seal engine to be loaded and change the Runner behaviour so the Clique seal engine and validators are loaded if chainspec declares them.
4. Create unit tests for ISealEngine implementation, unit tests for the new IBlockValidator / IBlockHeaderValidator.
5. Launch Nethermind and sync with Rinkeby test network (by providing a Rinkeby chainID).
6. Launch 4 nodes using RunnerSpawner to test a Clique based private network behaviour and proof that the ndoes can publish and validate nodes.
7. An implementation that is capable of (5) and (6) will be accepted. Core Nethermind team will be glad to provide all the help needed and introduce changes required to make code more consistent with the whole Nethermind codebase.

Limit the block queue size.

At the moment the growing block queue size breaks the mainnet syncs at the latest blocks. There should be a limit on blocks awaiting execution.

Possibly we should continue downloading blocks and just not keep them in memory and then allow the sync process to switch to loading blocks from DB when exhausting the blocks from memory.

AddPersistedPeers fails on initialization

PeerManager initialization fails at AddPersistedPeers. Reach out to me for a nodes DB to reproduce. This stops the entire sync process from moving forward.

Implement UInt256 multiplication

The code is in a separate solution - Nethermind.Dirichlet which is a fork of the UInt128 library

Make builds public

We run private TeamCity builds and we would like to allow community to contribute and run tests. Explore options and setup public continuous integration.

Remove unused hashlib code

We have incorporated HashLib into our solution but are only using a small subset of the assembly (Keccak256/512, RIPEMD, SHA3). It would make sense to remove everything else and add back only if needed.

Register a Nethermind node in ethstats

Either register one of our tets nodes VM or register some community nodes.
https://ethstats.net/
https://github.com/ethereum/wiki/wiki/Network-Status
cubedro/eth-netstats#328

EIP-1014

https://eips.ethereum.org/EIPS/eip-1014

Implement UInt256 division

In the Nethermind.Dirichlet submodule we have started some work on UInt256. For now, we use it for subtraction and addition. We would like to add reminding operations that would lead all the way to the division operator.

Clean RLP APIs

We would like to have RLP as a relatively independent library (either as a single project or coupled with Nethermind.Core only).

At the moment there are numerous APIs in RLP to allow for greater code optimization in Patricia Tree and other areas. As a result, the APIs can be confusing and not easily reusable in other projects.

Any changes here would need to assure that the existing optimizations are still supported.

In general, we have three approaches now:

1. original that does quite a lot of allocations
2. new one with creating buffers and block copy
3. newer one with spans

They also take different arguments depending on the level of optimizations needed (with Patricia Tree going most hardcore).

It would be great to review, improve and systematize the RLP APIs.

Setup Rocks DB monitoring / metrics

Allow to track Rocks DB metrics when running Nethermind

Replace SCrypt with a .NET Core compatible version

We have build warnings due to SCrypt library used that is targetting .NET Framework.

Remove PrecompileId from EVM (use Address)

Review and consider precompile to be identified by an address only, use precompile address constants.

Setup Constantinople branch and tests

Find an official list of Constantinople tasks, list them as issues on github, setup a branch and testing

Sharding support in Nethermind

Rename HashLib keccak class

IDEs resolve HashLib or Nethermind.Core Keccak class which may lead to confusion. We almost always want to resolve Nethermind.Core.Keccak.

Setup a public build server

We currently use a private TeamCity build server. For any open source contribution it would be desired to have a public build server where contributors can check their code for bugs before creating a pull request.

Integrate puppeth with Nethermind

Need to confirm that puppeth is client agnostic and that it could be used to create nethermind based private networks.
In case that is not possible we would like to see a puppeth-like tool for Nethermind

Choose best block by total difficulty instead of block number

While testing sync we used block number instead of total difficulty to select canonical chain. High time to fix it.

Fix the call depth in EVM traces

Call depth is not same as in Geth for some calls.

Setup Nethermind EVM benchmarks to compare with other Ethereum clients

Include benchmark run in continuos integration builds, setup reports and keep improving.
This will also benefit from BenchmarkingDotNet mentioned in another issue.

State pruning

Implement Aura (Kovan PoA)

As you can see below - Gitcoin bounty has been funded for this issue (kudos to Gitcoin team).
Below you will find more information on what is expected:

PoA / Aura spec is available here:

• https://wiki.parity.io/Pluggable-Consensus.html#aura
• https://wiki.parity.io/Aura.html

Best place to seek help from the team is Gitter:

• https://gitter.im/nethermindeth/nethermind

1. Write ISealEngine implementation representing Aura block sealing.
2. Write IBlockValidator / IBlockHeaderValidator to validate properly repurposed fields in BlockHeader
3. Make necessary changes to IChainSpecLoader to allow different seal engine to be loaded and change the Runner behaviour so the Clique seal engine and validators are loaded if chainspec declares them.
4. Create unit tests for ISealEngine implementation, unit tests for the new IBlockValidator / IBlockHeaderValidator.
5. Launch Nethermind and sync with Kovan test network (by providing a Kovan chainID).
6. Launch 4 nodes using RunnerSpawner to test a Aura based private network behaviour and proof that the nodes can publish and validate nodes.
7. An implementation that is capable of (5) and (6) will be accepted. Core Nethermind team will be glad to provide all the help needed and introduce changes required to make code more consistent with the whole Nethermind codebase.

Clean the EVM direct vs contract calls

TransactionProcessor and VirtualMachine both have a slightly different approach to creates and calls by which I mean that there is code that decides on what to do depending on whether we are the top level call or deeper. I believe some improvements can be done here to make the code more readable.

Swarm / BZZ support

Build initial Swarm/BZZ protocol implementation for Nethermind.

Support chainspec files fully

Read the seal engine spec and some EIP transition parameters from chainspec file. Possibly reogranize the spec provider approach to be more in line with chainspec files.

Finalize integration with Hive

Finalize the work done already on integration of Nethermind and Hive
https://github.com/karalabe/hive

Remove the Netty garbage logs displayed on application exit.

When exiting the client from console ('e' key) Netty flushes lots of garbage logs.

Create a set of consistent rules for EvmMemory locations.

While tests are passing we can clearly expose some attack vectors since memory is indexed through int and long values and location and size are specified as UInt256 in the yellowpaper.
Confront the rules with those in Parity and Geth.

Support eWASM

https://github.com/ewasm/design
https://github.com/RyanLamansky/dotnet-webassembly

Support Warp sync (PAR) in Nethermind

During DevCon there have been talks about the new approach to fast syncing and redesign of archive node storage.

Warp Sync spec is here:
https://wiki.parity.io/Warp-Sync

And there is a big chance that it is outdated and not very detailed. The warp sync integration may require a significant amount of reverse engineering from Parity source code (as with AuRa).

As such Warp Sync should only be considered after the fast sync work is finished.

Fine tune and document Rocks DB parameters

We should have better awareness of an impact of various Rocks DB parameters and include that in setup documentation for users.