# 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