Guard Tower Redux: Initial interface and struct setups for distributed key generation

Dockerfile

@@ -76,4 +76,4 @@ COPY --from=cbuild $INCLUDE_DIR $INCLUDE_DIR
 ENTRYPOINT ["keep-client", "-config",  "/keepclient/config.toml"]
 
 # docker caches more when using CMD [] resulting in a faster build.
-CMD []
+CMD []

go/beacon/broadcast/broadcast.go

@@ -0,0 +1,86 @@
+package broadcast
+
+import (
+	"sync"
+
+	"github.com/dfinity/go-dfinity-crypto/bls"
+)
+
+// Message represents a message to communicate over a broadcast channel.
+// TODO Combine with Raghav's work on protobuf messages.
+type Message struct {
+	Sender   bls.ID
+	Receiver *bls.ID // pointer so it can be nil for broadcast messages
+	Data     interface{}
+}
+
+// NewBroadcastMessage creates a new message from the given sender, carrying the
+// given data payload, meant for broacast into a channel watched by others. The
+// message is signed, but not encrypted.
+func NewBroadcastMessage(sender bls.ID, data interface{}) Message {
+	// FIXME Sign, will require private key...
+	return Message{sender, nil, data}
+}
+
+// NewPrivateMessage creates a new private message from the given sender to the
+// given receiver, carrying the given data payload, meant for broacast into a
+// channel watched by others. The message is signed and encrypted.
+func NewPrivateMessage(sender bls.ID, receiver bls.ID, data interface{}) Message {
+	// FIXME Actually encrypt here... Will require a key, best taken from
+	// FIXME chain...
+	return Message{sender, &receiver, data}
+}
+
+// Channel represents a named broadcast channel. It allows consumers to send
+// messages to the channel (via Send) and to access a low-level receive chan
+// that furnishes messages sent onto the broadcast channel.
+type Channel interface {
+	Name() string
+
+	Send(message Message) bool
+
+	RecvChan() <-chan Message
+}
+
+type localChannel struct {
+	name           string
+	recvChansMutex sync.Mutex
+	recvChans      []chan Message
+}
+
+func (channel *localChannel) Name() string {
+	return channel.name
+}
+
+func (channel *localChannel) Send(message Message) bool {
+	channel.recvChansMutex.Lock()
+	snapshot := make([]chan Message, len(channel.recvChans))
+	copy(snapshot, channel.recvChans)
+	channel.recvChansMutex.Unlock()
+	go func() {
+		for _, recvChan := range snapshot {
+			recvChan <- message
+		}
+	}()
+
+	return true
+}
+
+func (channel *localChannel) RecvChan() <-chan Message {
+	newChan := make(chan Message, 62500)
+
+	channel.recvChansMutex.Lock()
+	channel.recvChans = append(channel.recvChans, newChan)
+	channel.recvChansMutex.Unlock()
+
+	return newChan
+}
+
+// LocalChannel returns a Channel designed to mediate between local
+// participants. It delivers all messages sent to the channel through its
+// receive channels. RecvChan on a LocalChannel creates a new receive channel
+// that is returned to the caller, so that all receive channels can receive
+// the message.
+func LocalChannel(name string) Channel {
+	return &localChannel{name, sync.Mutex{}, make([]chan Message, 0)}
+}

go/beacon/chain/chain.go

@@ -0,0 +1,96 @@
+package chain
+
+import (
+	"sync"
+	"time"
+)
+
+// BlockCounter is an interface that provides the ability to wait for a certain
+// number of abstract blocks. It provides for two ways to wait, one blocking and
+// one chan-based. Block height is expected to increase monotonically, though
+// the time between blocks will depend on the underlying implementation. See
+// LocalBlockCounter() for a local implementation.
+type BlockCounter interface {
+	// WaitForBlocks blocks at the caller until numBlocks new blocks have been
+	// seen.
+	WaitForBlocks(numBlocks int)
+	// BlockWaiter returns a channel that will emit the current block height
+	// after the given number of blocks has elapsed and then immediately close.
+	BlockWaiter(numBlocks int) <-chan int
+}
+
+type localBlockCounter struct {
+	structMutex sync.Mutex
+	blockHeight int
+	waiters     map[int][]chan int
+}
+
+func (counter *localBlockCounter) WaitForBlocks(numBlocks int) {
+	waiter := counter.BlockWaiter(numBlocks)
+	<-waiter
+	return
+}
+
+func (counter *localBlockCounter) BlockWaiter(numBlocks int) <-chan int {
+	newWaiter := make(chan int)
+
+	counter.structMutex.Lock()
+	defer counter.structMutex.Unlock()
+	notifyBlockHeight := counter.blockHeight + numBlocks
+
+	if notifyBlockHeight <= counter.blockHeight {
+		newWaiter <- notifyBlockHeight
+	} else {
+		waiterList, exists := counter.waiters[notifyBlockHeight]
+		if !exists {
+			waiterList = make([]chan int, 0)
+		}
+
+		counter.waiters[notifyBlockHeight] = append(waiterList, newWaiter)
+	}
+
+	return newWaiter
+}
+
+func (counter *localBlockCounter) count() {
+	ticker := time.NewTicker(time.Duration(500 * time.Millisecond))
+
+	for _ = range ticker.C {
+		counter.structMutex.Lock()
+		counter.blockHeight++
+		height := counter.blockHeight
+		waiters, exists := counter.waiters[height]
+		delete(counter.waiters, height)
+		counter.structMutex.Unlock()
+
+		if exists {
+			for _, waiter := range waiters {
+				go func(w chan int) { w <- height }(waiter)
+			}
+		}
+	}
+}
+
+// LocalBlockCounter creates a BlockCounter that runs completely locally. It is
+// designed to simply increase block height at a set time interval in the
+// background.
+func LocalBlockCounter() BlockCounter {
+	counter := localBlockCounter{blockHeight: 0, waiters: make(map[int][]chan int)}
+
+	go counter.count()
+
+	return &counter
+}
+
+// BeaconConfig contains configuration for the threshold relay beacon, typically
+// from the underlying blockchain.
+type BeaconConfig struct {
+	GroupSize int
+	Threshold int
+}
+
+// GetBeaconConfig Get the latest threshold relay beacon configuration.
+// TODO Make this actually look up/update from chain information.
+func GetBeaconConfig() BeaconConfig {
+	return BeaconConfig{10, 4}
+}