Whisper Tests and Notes

Hypothesis

Whisper will start to drop messages at network capacity, and capacity will never be large enough to adopt a sufficient userbase.

Questions

When does the network fail?

At what point do we say the network fails?

• number of total dropped messages
• number of failed nodes
• poor propogation time
• reach bandwidth or storage limit

When does a node drop a message?

A node should drop a message if an intended listening node does not recieve it before the ttl is over.

When does a node reach capacity first?

A node can reach capacity either through bandwidth or storage.

When do we switch from ideal (worst case scenario) simulation conditions?

Initial simulations will probably be under ideal conditions that will give worst case scenarios:

• no bloom filters for topic listeners
• no proof of work for spam filters
• no peer reputation
• no spurious dropped/added peers
• no heirarchy of node structure (mailservers/clients)

Each of these things can increase the capacity of the network, but can drastically increase the complexity of the simulation and thus the time to complete it.

Plots required

• max/average node bandwidth as a function of time
  • This will give an idea of what min/max bandwidth requirements we have for running a single node in the network
• max/average node storage as a function of time
  • This will give an idea of what min/max storage requirements we have for running a single node in the network
• Total number of unreceived messages as a function of time
  • This will give an idea of at what point (under what parameters) the network starts to fail
• max/average redundant message posts on a node as a function of total messages
  • This will give an idea of bandwidth inefficiency there is across the network
  • total messages needs to be a better metric, maybe something graph related

Parameterized things to track

• test capacity as
  • number of nodes
  • number of messages/sec
    • poisson distribution
  • number of connections
• a given message \(m_i\) has:
  • size of message, \(m_{s,i}\)
    • poisson distribution
  • proof of work, \(m_{pow, i}\)
  • ttl, \(m_{ttl,i}\)
• a given node, \(node\), has:
  • messages/sec rate, \(node_{v,i}\)
    • poisson distribution
  • number of peers, \(node_{num\_p,i}\)
    • poisson distribution
      • reputation per peer link (spam)
        • dynamic based on devp2p
        • which means it can move within a given distribution
  • topic bloom filter, \(node_{b,i} \exists [0,1]\)

Whisper Spec Assumptions

• Upon reception of a message, a node will check if it already exists.
  • exists:
    • drop message
    • increment redundant message count
  • !exists:
    • add to hash table
    • broadcast to peers
• A message is considered failed if not all topic listeners received the message before ttl expires
  • Topic listeners is altered by node bloom filters

Some Definitions

\[ T_{m} = \sum_i^N{m_{i}} \]
\[ T_{s} = \sum_i^N{m_{s,i}} \]

Some potential considerations

• Investgate possibility of network splits due to aggressive bloom filtering
• Document attack avenues available - spamming, heterogenous computing power dilemma, etc
• It's crossed my mind to attack this problem with something like https://en.wikipedia.org/wiki/Queueing_theory - not sure about the feasibility of setting up a representative model here, but perhaps it can be commissioned as an academic cooperation