consensus/babe: load BABE authorities from genesis

codec/decode.go

@@ -366,7 +366,12 @@ func (sd *Decoder) DecodeArray(t interface{}) (interface{}, error) {
 			copy(arr[:], buf)
 			*ptr = arr
 		default:
-			err = errors.New("could not decode invalid slice or array")
+			var res interface{}
+			res, err = sd.DecodeCustom(sl.Index(i).Interface())
+			if err != nil {
+				return nil, err
+			}
+			arrayValue.Set(reflect.ValueOf(res))
 		}
 
 		if err != nil {
@@ -544,10 +549,12 @@ func (sd *Decoder) DecodeTuple(t interface{}) (interface{}, error) {
 				ptr := fieldValue.(*[]string)
 				*ptr = o.([]string)
 			default:
-				_, err = sd.Decode(v.Field(i).Interface())
+				o, err = sd.Decode(v.Field(i).Interface())
 				if err != nil {
 					break
 				}
+				// TODO: clean up this function, can use field.Set everywhere (remove switch case?)
+				field.Set(reflect.ValueOf(o))
 			}
 
 			if err != nil {

codec/decode_ptr.go

@@ -28,9 +28,9 @@ func DecodeCustom(in []byte, t interface{}) error {
 	someType := reflect.TypeOf(t)
 	_, ok := someType.MethodByName("Decode")
 	if ok {
-		meth := reflect.ValueOf(t).MethodByName("Decode")
+		method := reflect.ValueOf(t).MethodByName("Decode")
 		inVal := []reflect.Value{reflect.ValueOf(in)}
-		res := meth.Call(inVal)
+		res := method.Call(inVal)
 		err := res[0].Interface()
 		if err != nil {
 			return err.(error)
@@ -40,6 +40,25 @@ func DecodeCustom(in []byte, t interface{}) error {
 	return DecodePtr(in, t)
 }
 
+// DecodeCustom check if interface has method Decode(io.Reader), if so use that, otherwise use regular scale decoding
+func (sd *Decoder) DecodeCustom(t interface{}) (interface{}, error) {
+	someType := reflect.TypeOf(t)
+	_, ok := someType.MethodByName("Decode")
+	if ok {
+		meth := reflect.ValueOf(t).MethodByName("Decode")
+		inVal := []reflect.Value{reflect.ValueOf(sd.Reader)}
+		res := meth.Call(inVal)
+		err := res[1].Interface()
+		if err != nil {
+			return nil, err.(error)
+		}
+		t = res[0].Interface()
+		return t, nil
+	}
+
+	return nil, errors.New("cannot decode custom type")
+}
+
 // DecodePtr is the high level function wrapping the specific type decoding functions
 // The results of decode are written to t interface by reference (instead of returning
 //  value as Decode does)

common/common.go

@@ -176,3 +176,15 @@ func ReadUint64(r io.Reader) (uint64, error) {
 	}
 	return binary.LittleEndian.Uint64(buf), nil
 }
+
+// Read32Bytes reads 32 bytes from the reader and returns it
+func Read32Bytes(r io.Reader) ([32]byte, error) {
+	buf := make([]byte, 32)
+	_, err := r.Read(buf)
+	if err != nil {
+		return [32]byte{}, err
+	}
+	h := [32]byte{}
+	copy(h[:], buf)
+	return h, nil
+}

consensus/babe/babe.go

@@ -57,7 +57,6 @@ type SessionConfig struct {
 	Keypair        *sr25519.Keypair
 	Runtime        *runtime.Runtime
 	NewBlocks      chan<- types.Block
-	AuthorityIndex uint64
 	AuthData       []*AuthorityData
 	EpochThreshold *big.Int // should only be used for testing
 	Done           chan<- struct{}
@@ -76,7 +75,6 @@ func NewSession(cfg *SessionConfig) (*Session, error) {
 		txQueue:        new(tx.PriorityQueue),
 		slotToProof:    make(map[uint64]*VrfOutputAndProof),
 		newBlocks:      cfg.NewBlocks,
-		authorityIndex: cfg.AuthorityIndex,
 		authorityData:  cfg.AuthData,
 		epochThreshold: cfg.EpochThreshold,
 		done:           cfg.Done,
@@ -91,6 +89,13 @@ func NewSession(cfg *SessionConfig) (*Session, error) {
 
 	babeSession.randomness = [sr25519.VrfOutputLength]byte{babeSession.config.Randomness}
 
+	err = babeSession.setAuthorityIndex()
+	if err != nil {
+		return nil, err
+	}
+
+	log.Trace("BABE session", "authority index", babeSession.authorityIndex)
+
 	return babeSession, nil
 }
 
@@ -103,6 +108,8 @@ func (b *Session) Start() error {
 		}
 	}
 
+	log.Trace("BABE", "epochThreshold", b.epochThreshold)
+
 	var i uint64 = 0
 	var err error
 	for ; i < b.config.EpochLength; i++ {
@@ -127,9 +134,27 @@ func (b *Session) PeekFromTxQueue() *tx.ValidTransaction {
 	return b.txQueue.Peek()
 }
 
-func (b *Session) SetEpochData(data *NextEpochDescriptor) {
+func (b *Session) AuthorityData() []*AuthorityData {
+	return b.authorityData
+}
+
+func (b *Session) SetEpochData(data *NextEpochDescriptor) error {
 	b.authorityData = data.Authorities
 	b.randomness = data.Randomness
+	return b.setAuthorityIndex()
+}
+
+func (b *Session) setAuthorityIndex() error {
+	pub := b.keypair.Public()
+
+	for i, auth := range b.authorityData {
+		if bytes.Equal(pub.Encode(), auth.ID.Encode()) {
+			b.authorityIndex = uint64(i)
+			return nil
+		}
+	}
+
+	return fmt.Errorf("key not in BABE authority data")
 }
 
 func (b *Session) invokeBlockAuthoring() {
@@ -147,32 +172,34 @@ func (b *Session) invokeBlockAuthoring() {
 	}
 
 	for ; slotNum < b.config.EpochLength; slotNum++ {
-		parentHeader := b.blockState.LatestHeader()
-		if parentHeader == nil {
-			log.Error("BABE block authoring", "error", "parent header is nil")
-		} else {
-			currentSlot := Slot{
-				start:    uint64(time.Now().Unix()),
-				duration: b.config.SlotDuration,
-				number:   slotNum,
-			}
-
-			block, err := b.buildBlock(parentHeader, currentSlot)
-			if err != nil {
-				log.Error("BABE block authoring", "error", err)
+		if b.slotToProof[slotNum] != nil {
+			parentHeader := b.blockState.LatestHeader()
+			if parentHeader == nil {
+				log.Error("BABE block authoring", "error", "parent header is nil")
 			} else {
-				hash := block.Header.Hash()
-				log.Info("BABE", "built block", hash.String(), "number", block.Header.Number)
-				log.Debug("BABE built block", "header", block.Header, "body", block.Body)
-				b.newBlocks <- *block
-				err = b.blockState.AddBlock(block)
+				currentSlot := Slot{
+					start:    uint64(time.Now().Unix()),
+					duration: b.config.SlotDuration,
+					number:   slotNum,
+				}
+
+				block, err := b.buildBlock(parentHeader, currentSlot)
 				if err != nil {
 					log.Error("BABE block authoring", "error", err)
+				} else {
+					hash := block.Header.Hash()
+					log.Info("BABE", "built block", hash.String(), "number", block.Header.Number)
+					log.Debug("BABE built block", "header", block.Header, "body", block.Body)
+					b.newBlocks <- *block
+					err = b.blockState.AddBlock(block)
+					if err != nil {
+						log.Error("BABE block authoring", "error", err)
+					}
 				}
 			}
-		}
 
-		time.Sleep(time.Millisecond * time.Duration(b.config.SlotDuration))
+			time.Sleep(time.Millisecond * time.Duration(b.config.SlotDuration))
+		}
 	}
 
 	if b.newBlocks != nil {
@@ -210,6 +237,7 @@ func (b *Session) runLottery(slot uint64) (*VrfOutputAndProof, error) {
 		copy(outbytes[:], output)
 		proofbytes := [sr25519.VrfProofLength]byte{}
 		copy(proofbytes[:], proof)
+		log.Trace("BABE lottery", "won slot", slot)
 		return &VrfOutputAndProof{
 			output: outbytes,
 			proof:  proofbytes,
@@ -241,7 +269,7 @@ func (b *Session) setEpochThreshold() error {
 func (b *Session) authorityWeights() []uint64 {
 	weights := make([]uint64, len(b.authorityData))
 	for i, auth := range b.authorityData {
-		weights[i] = auth.weight
+		weights[i] = auth.Weight
 	}
 	return weights
 }