consensys / wittgenstein Goto Github PK
View Code? Open in Web Editor NEWSimulator for some PoS or consensus algorithms. Includes dfinity, casper IMD and others
License: Apache License 2.0
Simulator for some PoS or consensus algorithms. Includes dfinity, casper IMD and others
License: Apache License 2.0
EIP for ENR itself it here: https://eips.ethereum.org/EIPS/eip-778
One of the proposal to communicate the ENDR, likely the simplest one actually, is that each node gossip periodically its ENR. There are at least three things to take care about:
The basic protocol would be:
We will measure, for around 20K nodes:
cc @carver
The real world latency measurement used in NetworkLatencyByCity are for rtt (round trip time), our model require one way latency time.
fix: divide latency time by 2
Add to gradle a measure of the test coverage
Increase the test coverage
That means:
The paper is here: https://fc18.ifca.ai/preproceedings/75.pdf
It didn't measure variance.
Add documentation that explain how to create new graphs, change parameters etc..
Hi,
I am planning on writing a Dandelion++ Simulation on top of a gossipsub network in order to test some ideas outlined in this issue.
As it currently stands, I would have to build 2-3 protocols, one for a gossipsub network, one for Dandelion++ and another for sharding.
As a potential future feature of this simulation library, would it make sense to have some default network protocols that simulators can choose from?
Today, they are implemented, but outside of the framework. Their implementation should be integrated in the framework.
We should be able to support dead nodes in the framework, including the fact that it's sometimes possible to detect dead nodes
Build a protocol that simulates pow algorithms, uses difficulty calculations and includes uncles:
For Uncle creation
Before adding as uncle:
Refactoring
Mining
** Data collection**
Generate data and store it outside with minimum parameters necessary
Of course, all the graph should be generated
Node#start was just added, and it called at the first run.
Our current graphs don't allow us to appreciate what happens in the first rounds of the protocol. Having a log scale graph (i.e. plotting log_2(number of signatures aggregated) over time) would allow us to see what happens in the early stages of the protocol execution.
We might thus be able to see how vulnerable the initial phases of the protocol are wrt to byzantine actors etc...
It should be possible to have two types of nodes:
In real life, there are multiple reasons for such deployments, including:
We can use real latency measurements for latencies instead of the linear regression model.
For example, define multiple type of nodes and then proportion of each of them. This should be managed by the framework
For example, run a scenario with a partition at a given moment and try it on different blockchain.
It's obviously complicated to implement.
See libp2p doc here: https://github.com/libp2p/specs/tree/master/pubsub/gossipsub
The basic protocol is quite simple:
"With flooding, routing is almost trivial: for each incoming message, forward to all known peers in the topic. There is a bit of logic, as the router maintains a timed cache of previous messages, so that seen messages are not further forwarded. It also never forwards a message back to the source or the peer that forwarded the message."
The Network
class should have an overloaded method send
which takes an unique destination as argument instead of taking only a collection. That would relieve us to use the Collections.singleton()
trick.
This will be possible by allowing external process to send/receive message through http/json
This will be slow however. But an interesting scenario will the one byzantine node (implemented externally) with all other nodes implemented in java. With just a few external nodes it should be fast enough
We have min/max/avg today.
Today it's independant
This will allow to have better results: today we run it once and we just hope it's representative
There is a link with a scenario requirement, but it's a design decision.
We will be allowed to use the position from the known ethereum projects (https://www.ethernodes.org/network/1)
We will use the project hanon for this.
Today all the nodes are connected at the beginning, we don't manage any disconnection/reconnection in the framework. We need it for the ENR
It's now possible to launch protocols using rest services. We need an UI on top of this
A declarative, efficient, and flexible JavaScript library for building user interfaces.
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
The Web framework for perfectionists with deadlines.
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
We are working to build community through open source technology. NB: members must have two-factor auth.
Open source projects and samples from Microsoft.
Google ❤️ Open Source for everyone.
Alibaba Open Source for everyone
Data-Driven Documents codes.
China tencent open source team.