Rollup protocol (#2321)

* Rollup protocol

Previously the leader polled for new transactions. This is inefficient,
as new transactions have to wait for the leader to poll.

With this PR, the all followers forward transactions directly to the leader.
Once the leader has a transaction, he directly starts a new block.
Once the new block has been accepted, eventually queued up transactions
are also sent.

This has been tested to be able to go from old nodes to new nodes on a
local machine.

* Tharvik's comments

byzcoin/api_test.go

@@ -228,9 +228,6 @@ func TestClient_Streaming(t *testing.T) {
 			require.NoError(t, err)
 			_, err = c.AddTransaction(tx)
 			require.NoError(t, err)
-
-			// sleep for a block interval so we create multiple blocks
-			time.Sleep(msg.BlockInterval)
 		}
 	}()
 
@@ -363,19 +360,15 @@ type corruptedService struct {
 
 func newTestService(c *onet.Context) (onet.Service, error) {
 	s := &Service{
-		ServiceProcessor:       onet.NewServiceProcessor(c),
-		contracts:              newContractRegistry(),
-		txBuffer:               newTxBuffer(),
-		storage:                &bcStorage{},
-		darcToSc:               make(map[string]skipchain.SkipBlockID),
-		stateChangeCache:       newStateChangeCache(),
-		stateChangeStorage:     newStateChangeStorage(c),
-		heartbeatsTimeout:      make(chan string, 1),
-		closeLeaderMonitorChan: make(chan bool, 1),
-		heartbeats:             newHeartbeats(),
-		viewChangeMan:          newViewChangeManager(),
-		streamingMan:           streamingManager{},
-		closed:                 true,
+		ServiceProcessor:   onet.NewServiceProcessor(c),
+		contracts:          newContractRegistry(),
+		storage:            &bcStorage{},
+		darcToSc:           make(map[string]skipchain.SkipBlockID),
+		stateChangeCache:   newStateChangeCache(),
+		stateChangeStorage: newStateChangeStorage(c),
+		viewChangeMan:      newViewChangeManager(),
+		streamingMan:       streamingManager{},
+		closed:             true,
 	}
 
 	cs := &corruptedService{Service: s}