adds state

packages/binary/drng/dispatcher.go

+package drng
+
+import (
+	"github.com/iotaledger/goshimmer/packages/binary/drng/payload/header"
+	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transaction"
+)
+
+func Dispatch(subtype header.Type, tx *transaction.Transaction) {
+	switch subtype {
+	case header.CollectiveBeaconType():
+		//do stuff
+	default:
+		//do other stuff
+	}
+}

packages/binary/drng/drng.go

 package drng
 
 import (
-	"crypto/sha512"
-	"errors"
-
-	"github.com/drand/drand/beacon"
-	"github.com/drand/drand/key"
-	"github.com/iotaledger/goshimmer/packages/binary/drng/payload/collectiveBeacon"
+	"github.com/iotaledger/goshimmer/packages/binary/drng/state"
+	"github.com/iotaledger/hive.go/events"
 )
 
-// VerifyCollectiveBeacon checks the current signature against the distributed public key
-func VerifyCollectiveBeacon(data *collectiveBeacon.Payload) error {
-	if data == nil {
-		return errors.New("nil data")
-	}
-
-	dpk := key.KeyGroup.Point()
-	if err := dpk.UnmarshalBinary(data.DistributedPK()); err != nil {
-		return err
-	}
-
-	msg := beacon.Message(data.PrevSignature(), data.Round())
-
-	if err := key.Scheme.VerifyRecovered(dpk, msg, data.Signature()); err != nil {
-		return err
-	}
-
-	return nil
+type Instance struct {
+	State  *state.State
+	Events *events.Event
 }
 
-// GetRandomness returns the randomness from a given signature
-func GetRandomness(signature []byte) ([]byte, error) {
-	hash := sha512.New()
-	if _, err := hash.Write(signature); err != nil {
-		return nil, err
+func New() *Instance {
+	return &Instance{
+		State: state.New(),
 	}
-
-	return hash.Sum(nil), nil
 }

packages/binary/drng/events.go

+package drng
+
+import (
+	"github.com/iotaledger/hive.go/events"
+)
+
+var Events = struct {
+	NewRandomness *events.Event
+}{
+	NewRandomness: events.NewEvent(transactionCaller),
+}
+
+func transactionCaller(handler interface{}, params ...interface{}) {
+	//handler.(func(*value_transaction.ValueTransaction))(params[0].(*value_transaction.ValueTransaction))
+}

packages/binary/drng/state/options.go

+package state
+
+type Options struct {
+	Committee  *Committee
+	Randomness *Randomness
+}
+
+type option func(*Options)
+
+// SetCommittee sets the initial committee
+func SetCommittee(c *Committee) option {
+	return func(args *Options) {
+		args.Committee = c
+	}
+}
+
+// SetRandomness sets the initial randomness
+func SetRandomness(r *Randomness) option {
+	return func(args *Options) {
+		args.Randomness = r
+	}
+}

packages/binary/drng/state/state.go

+package state
+
+import (
+	"sync"
+	"time"
+
+	"github.com/iotaledger/goshimmer/packages/binary/signature/ed25119"
+)
+
+type Randomness struct {
+	Round      uint64
+	Randomness []byte
+	Timestamp  time.Time
+}
+
+type Committee struct {
+	InstanceID    uint32
+	Threshold     uint8
+	Identities    []ed25119.PublicKey
+	DistributedPK []byte
+}
+
+type State struct {
+	randomness *Randomness
+	committe   *Committee
+
+	mutex sync.RWMutex
+}
+
+func New(setters ...option) *State {
+	args := &Options{}
+
+	for _, setter := range setters {
+		setter(args)
+	}
+	return &State{
+		randomness: args.Randomness,
+		committe:   args.Committee,
+	}
+}
+
+func (s *State) SetRandomness(r *Randomness) {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+	s.randomness = r
+}
+
+func (s *State) Randomness() Randomness {
+	s.mutex.RLock()
+	defer s.mutex.RUnlock()
+	return *s.randomness
+}
+
+func (s *State) SetCommittee(c *Committee) {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+	s.committe = c
+}
+
+func (s *State) Committee() Committee {
+	s.mutex.RLock()
+	defer s.mutex.RUnlock()
+	return *s.committe
+}

packages/binary/drng/state/state_test.go

+package state
+
+import (
+	"testing"
+	"time"
+
+	"github.com/iotaledger/goshimmer/packages/binary/signature/ed25119"
+	"github.com/stretchr/testify/require"
+)
+
+func dummyRandomness() *Randomness {
+	return &Randomness{
+		Round:      0,
+		Randomness: []byte{},
+	}
+}
+
+func dummyCommittee() *Committee {
+	return &Committee{
+		InstanceID:    0,
+		Threshold:     0,
+		Identities:    []ed25119.PublicKey{},
+		DistributedPK: []byte{},
+	}
+}
+
+func TestState(t *testing.T) {
+	// constructor
+	stateTest := New(SetCommittee(dummyCommittee()), SetRandomness(dummyRandomness()))
+	require.Equal(t, *dummyRandomness(), stateTest.Randomness())
+	require.Equal(t, *dummyCommittee(), stateTest.Committee())
+
+	// committee setters - getters
+	newCommittee := &Committee{1, 1, []ed25119.PublicKey{}, []byte{11}}
+	stateTest.SetCommittee(newCommittee)
+	require.Equal(t, *newCommittee, stateTest.Committee())
+
+	// randomness setters - getters
+	newRandomness := &Randomness{1, []byte{123}, time.Now()}
+	stateTest.SetRandomness(newRandomness)
+	require.Equal(t, *newRandomness, stateTest.Randomness())
+}

packages/binary/drng/subtypes/collectiveBeacon/collective_beacon.go

+package collectiveBeacon
+
+import (
+	"crypto/sha512"
+	"errors"
+
+	"github.com/drand/drand/beacon"
+	"github.com/drand/drand/key"
+	"github.com/iotaledger/goshimmer/packages/binary/drng/subtypes/collectiveBeacon/payload"
+)
+
+// VerifyCollectiveBeacon checks the current signature against the distributed public key
+func VerifyCollectiveBeacon(data *payload.Payload) error {
+	if data == nil {
+		return errors.New("nil data")
+	}
+
+	dpk := key.KeyGroup.Point()
+	if err := dpk.UnmarshalBinary(data.DistributedPK()); err != nil {
+		return err
+	}
+
+	msg := beacon.Message(data.PrevSignature(), data.Round())
+
+	if err := key.Scheme.VerifyRecovered(dpk, msg, data.Signature()); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// GetRandomness returns the randomness from a given signature
+func GetRandomness(signature []byte) ([]byte, error) {
+	hash := sha512.New()
+	if _, err := hash.Write(signature); err != nil {
+		return nil, err
+	}
+
+	return hash.Sum(nil), nil
+}

packages/binary/drng/drng_test.go → packages/binary/drng/subtypes/collectiveBeacon/collective_beacon_test.go

-package drng
+package collectiveBeacon
 
 import (
 	"encoding/hex"
 	"testing"
 
-	"github.com/iotaledger/goshimmer/packages/binary/drng/payload/collectiveBeacon"
+	"github.com/iotaledger/goshimmer/packages/binary/drng/subtypes/collectiveBeacon/payload"
 	"github.com/stretchr/testify/require"
 )
 
 var (
-	payloadTest       *collectiveBeacon.Payload
+	payloadTest       *payload.Payload
 	prevSignatureTest []byte
 	signatureTest     []byte
 	dpkTest           []byte
@@ -19,7 +19,7 @@ func init() {
 	prevSignatureTest, _ = hex.DecodeString("ae9ba6d1445bffea8e66cb7d28fe5924e0a8d31b11b62a8710204e56e1ba84bc3694a3033e5793fcee6e75e956e5da3016cd0e22aa46fa419cd06343a7ff9d1e9c5c08f660f0bdec099e97ef99f470bb8c607ce9667a165e9caa474710f62ffd")
 	signatureTest, _ = hex.DecodeString("8dee56fae60dcad960f7176d0813d5415b930cf6e20c299ec2c2dfc5f2ad4903916fd462ba1abf5c32a5bfd94dcc8eba062d011a548d99df7fa1e3bbbc9a0455663d60f6ccc736c1d5b6de727dbe4427e21fb660925518be386265913f447c94")
 	dpkTest, _ = hex.DecodeString("a02fcd15edd52c8e134027491a43b597505b466d1679e88f70f927e57c45a93ae0765ff02fc2d015e3a02fd8748e2103")
-	payloadTest = collectiveBeacon.New(1, 1, prevSignatureTest, signatureTest, dpkTest)
+	payloadTest = payload.New(1, 1, prevSignatureTest, signatureTest, dpkTest)
 }
 
 func TestVerifyCollectiveBeacon(t *testing.T) {

packages/binary/drng/payload/collectiveBeacon/common.go → packages/binary/drng/subtypes/collectiveBeacon/payload/common.go

-package collectiveBeacon
+package payload
 
 const (
 	// BLS Signature size in bytes

packages/binary/drng/payload/collectiveBeacon/collective_beacon.go → packages/binary/drng/subtypes/collectiveBeacon/payload/payload.go

-package collectiveBeacon
+package payload
 
 import (
 	"sync"

packages/binary/drng/payload/collectiveBeacon/collective_beacon_test.go → packages/binary/drng/subtypes/collectiveBeacon/payload/payload_test.go

-package collectiveBeacon
+package payload
 
 import (
 	"testing"